diff --git a/org.apache.click.eclipse.cayenne/.classpath b/org.apache.click.eclipse.cayenne/.classpath
new file mode 100644
index 0000000..2d1a430
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/org.apache.click.eclipse.cayenne/.project b/org.apache.click.eclipse.cayenne/.project
new file mode 100644
index 0000000..96b1d0e
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.apache.click.eclipse.cayenne</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.apache.click.eclipse.cayenne/.settings/org.eclipse.jdt.core.prefs b/org.apache.click.eclipse.cayenne/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..9fcfaca
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,12 @@
+#Tue Jul 21 00:12:05 JST 2009
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/org.apache.click.eclipse.cayenne/META-INF/MANIFEST.MF b/org.apache.click.eclipse.cayenne/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..d9ad221
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/META-INF/MANIFEST.MF
@@ -0,0 +1,19 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: Cayenne Plug-In
+Bundle-SymbolicName: org.apache.click.eclipse.cayenne;singleton:=true
+Bundle-Version: 2.1.0.0
+Bundle-Activator: org.apache.click.eclipse.cayenne.CayennePlugin
+Require-Bundle: org.eclipse.ui,
+ org.eclipse.core.runtime,
+ org.eclipse.jdt.launching,
+ org.eclipse.debug.core,
+ org.eclipse.ui.ide,
+ org.eclipse.jdt.core,
+ org.eclipse.jdt.ui
+Bundle-ActivationPolicy: lazy
+Bundle-ClassPath: .
+Export-Package: org.apache.click.eclipse.cayenne,
+ org.apache.click.eclipse.cayenne.editor,
+ org.apache.click.eclipse.cayenne.wizard
+Bundle-RequiredExecutionEnvironment: J2SE-1.5
diff --git a/org.apache.click.eclipse.cayenne/build.properties b/org.apache.click.eclipse.cayenne/build.properties
new file mode 100644
index 0000000..99a5459
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/build.properties
@@ -0,0 +1,25 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml,\
+               cayenne/,\
+               icons/
+src.includes = src/
diff --git a/org.apache.click.eclipse.cayenne/cayenne/CayenneModeler.jar b/org.apache.click.eclipse.cayenne/cayenne/CayenneModeler.jar
new file mode 100644
index 0000000..b365c41
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/cayenne/CayenneModeler.jar
Binary files differ
diff --git a/org.apache.click.eclipse.cayenne/cayenne/ashwood-2.0.jar b/org.apache.click.eclipse.cayenne/cayenne/ashwood-2.0.jar
new file mode 100644
index 0000000..55fcc9b
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/cayenne/ashwood-2.0.jar
Binary files differ
diff --git a/org.apache.click.eclipse.cayenne/cayenne/cayenne-server-3.0M6.jar b/org.apache.click.eclipse.cayenne/cayenne/cayenne-server-3.0M6.jar
new file mode 100644
index 0000000..fdf0d05
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/cayenne/cayenne-server-3.0M6.jar
Binary files differ
diff --git a/org.apache.click.eclipse.cayenne/cayenne/commons-collections-3.1.jar b/org.apache.click.eclipse.cayenne/cayenne/commons-collections-3.1.jar
new file mode 100644
index 0000000..41e230f
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/cayenne/commons-collections-3.1.jar
Binary files differ
diff --git a/org.apache.click.eclipse.cayenne/cayenne/commons-logging-1.1.jar b/org.apache.click.eclipse.cayenne/cayenne/commons-logging-1.1.jar
new file mode 100644
index 0000000..2ff9bbd
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/cayenne/commons-logging-1.1.jar
Binary files differ
diff --git a/org.apache.click.eclipse.cayenne/icons/cayenne.png b/org.apache.click.eclipse.cayenne/icons/cayenne.png
new file mode 100644
index 0000000..b758cea
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/icons/cayenne.png
Binary files differ
diff --git a/org.apache.click.eclipse.cayenne/plugin.xml b/org.apache.click.eclipse.cayenne/plugin.xml
new file mode 100644
index 0000000..f6a85f0
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/plugin.xml
@@ -0,0 +1,68 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.2"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<plugin>
+   <extension
+         point="org.eclipse.ui.editors">
+      <editor
+            filenames="cayenne.xml"
+            icon="icons/cayenne.png"
+            id="org.apache.click.eclipse.cayenne.editor.CayenneModelerLauncher"
+            launcher="org.apache.click.eclipse.cayenne.editor.CayenneModelerLauncher"
+            name="Cayenne Modeler">
+      </editor>
+   </extension>
+   <extension
+         point="org.eclipse.ui.newWizards">
+      <category
+            id="org.apache.click.eclipse.cayenne"
+            name="Cayenne">
+      </category>
+      <wizard
+            category="org.apache.click.eclipse.cayenne"
+            class="org.apache.click.eclipse.cayenne.wizard.NewCayenneWizard"
+            icon="icons/cayenne.png"
+            id="org.apache.click.eclipse.cayenne.wizard"
+            name="Cayenne Mapping Project">
+      </wizard>
+   </extension>
+   <extension
+         point="org.eclipse.jdt.core.classpathContainerInitializer">
+      <classpathContainerInitializer
+         class="org.apache.click.eclipse.cayenne.CayenneClasspathContainerInitializer"
+         id="org.apache.click.eclipse.cayenne.CAYENNE_LIBS"/>
+   </extension>
+   <extension
+         point="org.eclipse.jdt.ui.classpathContainerPage">
+      <classpathContainerPath 
+         class="org.apache.click.eclipse.cayenne.CayenneClasspathContainerPage"
+         id="org.apache.click.eclipse.cayenne.CAYENNE_LIBS"
+         name="Cayennne Libraries"/>
+   </extension>
+   <!--
+   <extension
+         point="org.eclipse.jdt.core.classpathVariableInitializer">
+      <classpathVariableInitializer
+            class="org.apache.click.eclipse.cayenne.CayenneClasspathVariableInitializer"
+            variable="org.apache.click.eclipse.cayenne.classpathVariableInitializer">
+      </classpathVariableInitializer>
+   </extension>
+   -->
+</plugin>
diff --git a/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/CayenneClasspathContainerInitializer.java b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/CayenneClasspathContainerInitializer.java
new file mode 100644
index 0000000..d935ffd
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/CayenneClasspathContainerInitializer.java
@@ -0,0 +1,105 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.cayenne;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.FileLocator;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jdt.core.ClasspathContainerInitializer;
+import org.eclipse.jdt.core.IClasspathContainer;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+import org.osgi.framework.Bundle;
+
+/**
+ * Provides classpath container <tt>CAYENNE_LIBS</tt>.
+ *
+ * @author Naoki Takezoe
+ */
+public class CayenneClasspathContainerInitializer extends ClasspathContainerInitializer {
+
+	public static final String CONTAINER_ID = "org.apache.click.eclipse.cayenne.CAYENNE_LIBS";
+
+	public void initialize(final IPath containerPath, IJavaProject project) throws CoreException {
+
+		final IClasspathEntry[] entries = new IClasspathEntry[]{
+				getLibraryEntry("cayenne/cayenne-server-3.0M6.jar"),
+				getLibraryEntry("cayenne/ashwood-2.0.jar"),
+				getLibraryEntry("cayenne/commons-collections-3.1.jar"),
+				getLibraryEntry("cayenne/commons-logging-1.1.jar"),
+		};
+
+		IClasspathContainer container = new IClasspathContainer() {
+
+			public IPath getPath() {
+				return containerPath;
+			}
+
+			public int getKind() {
+				return IClasspathContainer.K_APPLICATION;
+			}
+
+			public String getDescription() {
+				return "Cayenne Libraries";
+			}
+
+			public IClasspathEntry[] getClasspathEntries() {
+				return entries;
+			}
+		};
+
+		JavaCore.setClasspathContainer(containerPath,
+				new IJavaProject[]{project},
+				new IClasspathContainer[]{container},
+				null);
+	}
+
+	private static IClasspathEntry getLibraryEntry(String path){
+		IPath bundleBase = getBundleLocation();
+		if(bundleBase != null){
+			IPath jarLocation = bundleBase.append(path);
+			return JavaCore.newLibraryEntry(jarLocation, null, null);
+		}
+		return null;
+	}
+
+
+	private static IPath getBundleLocation(){
+		Bundle bundle = CayennePlugin.getDefault().getBundle();
+		if(bundle == null){
+			return null;
+		}
+
+		URL local = null;
+		try {
+			local = FileLocator.toFileURL(bundle.getEntry("/"));
+		} catch(IOException ex){
+			return null;
+		}
+
+		String fullPath = new File(local.getPath()).getAbsolutePath();
+		return Path.fromOSString(fullPath);
+	}
+}
diff --git a/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/CayenneClasspathContainerPage.java b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/CayenneClasspathContainerPage.java
new file mode 100644
index 0000000..5e154d3
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/CayenneClasspathContainerPage.java
@@ -0,0 +1,63 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.cayenne;
+
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.ui.wizards.IClasspathContainerPage;
+import org.eclipse.jface.wizard.WizardPage;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+
+/**
+ *
+ * @author Naoki Takezoe
+ */
+public class CayenneClasspathContainerPage extends WizardPage implements IClasspathContainerPage {
+
+	private IClasspathEntry containerEntryResult;
+
+	public CayenneClasspathContainerPage() {
+		super("CayenneClasspathContainerPage");
+		setTitle("Cayenne Libraries");
+		setDescription(CayennePlugin.getString("wizard.classpathContainer.description"));
+	}
+
+	public boolean finish() {
+		containerEntryResult = JavaCore.newContainerEntry(
+				new Path(CayenneClasspathContainerInitializer.CONTAINER_ID));
+		return true;
+	}
+
+	public IClasspathEntry getSelection() {
+		return containerEntryResult;
+	}
+
+	public void setSelection(IClasspathEntry entry) {
+	}
+
+	public void createControl(Composite parent) {
+		Composite composite = new Composite(parent, SWT.NULL);
+		composite.setLayout(new GridLayout());
+		setControl(composite);
+	}
+
+}
diff --git a/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/CayennePlugin.java b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/CayennePlugin.java
new file mode 100644
index 0000000..79d3bdf
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/CayennePlugin.java
@@ -0,0 +1,175 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.cayenne;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.URL;
+import java.util.ResourceBundle;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.osgi.framework.BundleContext;
+
+/**
+ * The activator class controls the plug-in life cycle
+ */
+public class CayennePlugin extends AbstractUIPlugin {
+
+	// The plug-in ID
+	public static final String PLUGIN_ID = "org.apache.click.eclipse.cayenne";
+
+	// The shared instance
+	private static CayennePlugin plugin;
+	
+	private ResourceBundle resource;
+	
+	/**
+	 * The constructor
+	 */
+	public CayennePlugin() {
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext)
+	 */
+	public void start(BundleContext context) throws Exception {
+		super.start(context);
+		plugin = this;
+		resource = ResourceBundle.getBundle("org.apache.click.eclipse.cayenne.messages");
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext)
+	 */
+	public void stop(BundleContext context) throws Exception {
+		plugin = null;
+		super.stop(context);
+	}
+
+	/**
+	 * Returns the shared instance
+	 *
+	 * @return the shared instance
+	 */
+	public static CayennePlugin getDefault() {
+		return plugin;
+	}
+	
+	public static String getString(String key){
+		return getDefault().resource.getString(key);
+	}
+	
+	/**
+	 * JAR files for Cayenne Modeler.
+	 */
+	private static File[] files;
+	
+	/**
+	 * 
+	 * @return
+	 */
+	public static File[] getCayenneModelerClassPaths(){
+		if(files!=null){
+			return files;
+		}
+		File dir = CayennePlugin.getDefault().getStateLocation().toFile();
+		files = new File[]{
+//				new File(dir, "cayenne.jar"),
+//				new File(dir, "cayenne-modeler.jar"),
+//				new File(dir, "commons-dbcp-1.2.1.jar"),
+//				new File(dir, "commons-pool-1.2.jar"),
+//				new File(dir, "forms-1.0.3.jar"),
+//				new File(dir, "hsqldb-1.8.0.2.jar"),
+//				new File(dir, "looks-1.3.1.jar"),
+//				new File(dir, "ognl-2.6.7.jar"),
+//				new File(dir, "scope-bin-1.0.1.jar"),
+				new File(dir, "CayenneModeler.jar"),
+		};
+		return files;
+	}
+	
+	/**
+	 * 
+	 * @return
+	 */
+	public static String[] getCayenneModelerClassPathAsStringArray(){
+		File[] files = getCayenneModelerClassPaths();
+		String[] paths = new String[files.length];
+		for(int i=0;i<files.length;i++){
+			paths[i] = files[i].getAbsolutePath();
+		}
+		return paths;
+	}
+	
+	/**
+	 * 
+	 * @throws CoreException
+	 */
+	public static void copyCayenneModelerLibraries() throws CoreException {
+		File[] files = getCayenneModelerClassPaths();
+		for(int i=0;i<files.length;i++){
+			if(!files[i].exists()){
+				copyFile(CayennePlugin.getDefault().getBundle().getEntry(
+						"/cayenne/" + files[i].getName()), files[i]);
+			}
+		}
+	}
+	
+//	/**
+//	 * 
+//	 * @throws CoreException
+//	 */
+//	public static void removeCayenneModelerLibraries() throws CoreException {
+//		File[] files = getCayenneModelerClassPaths();
+//		for(int i=0;i<files.length;i++){
+//			if(files[i].exists()){
+//				files[i].delete();
+//			}
+//		}
+//	}
+	
+	private static void copyFile(URL url, File file) throws CoreException {
+		try {
+			InputStream in = url.openStream();
+			OutputStream out = new FileOutputStream(file);
+			try {
+				byte[] buf = new byte[1024 * 8];
+				int length = 0;
+				while((length = in.read(buf))!=-1){
+					out.write(buf, 0, length);
+				}
+			} finally {
+				in.close();
+				out.close();
+			}
+		} catch(Exception ex){
+			IStatus status = new Status(
+					IStatus.ERROR, CayennePlugin.PLUGIN_ID, 0, ex.toString(), ex);
+			throw new CoreException(status);
+		}
+	}	
+
+}
diff --git a/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/editor/CayenneModelerLauncher.java b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/editor/CayenneModelerLauncher.java
new file mode 100644
index 0000000..e58eb36
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/editor/CayenneModelerLauncher.java
@@ -0,0 +1,76 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.cayenne.editor;
+
+import java.io.File;
+
+
+import org.apache.click.eclipse.cayenne.CayennePlugin;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.debug.core.ILaunchManager;
+import org.eclipse.debug.core.Launch;
+import org.eclipse.jdt.launching.IVMRunner;
+import org.eclipse.jdt.launching.JavaRuntime;
+import org.eclipse.jdt.launching.VMRunnerConfiguration;
+import org.eclipse.ui.IEditorLauncher;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class CayenneModelerLauncher implements IEditorLauncher {
+	
+	public static final String EDITOR_ID = CayenneModelerLauncher.class.getName();
+	
+	private boolean firstOpen = true;
+	
+	public void open(IPath file) {
+		// Copy JAR files for Cayenne Modeler.
+		if(firstOpen){
+			try {
+				CayennePlugin.copyCayenneModelerLibraries();
+			} catch(Exception ex){
+				ex.printStackTrace();
+			}
+		}
+		
+		firstOpen = false;
+		
+		try {
+			File[] jarFiles = CayennePlugin.getCayenneModelerClassPaths();
+			String[] classpath = new String[jarFiles.length];
+			for(int i=0;i<jarFiles.length;i++){
+				classpath[i] = jarFiles[i].getAbsolutePath();
+			}
+			
+			VMRunnerConfiguration vmConfig = new VMRunnerConfiguration(
+					"org.apache.cayenne.modeler.Main", classpath);
+			vmConfig.setProgramArguments(new String[]{file.makeAbsolute().toString()});
+			
+			Launch launch = new Launch(null, ILaunchManager.RUN_MODE, null);
+			IVMRunner vmRunner = JavaRuntime.getDefaultVMInstall().getVMRunner(
+					ILaunchManager.RUN_MODE);
+			
+			vmRunner.run(vmConfig, launch, null);
+		} catch(Exception ex){
+			ex.printStackTrace();
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/messages.properties b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/messages.properties
new file mode 100644
index 0000000..a8f051a
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/messages.properties
@@ -0,0 +1,18 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+wizard.classpathContainer.description=Add Cayenne libraries to classpath.
\ No newline at end of file
diff --git a/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/messages_ja.properties b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/messages_ja.properties
new file mode 100644
index 0000000..5ac35ea
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/messages_ja.properties
@@ -0,0 +1,18 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+wizard.classpathContainer.description=Cayenne\u306e\u30e9\u30a4\u30d6\u30e9\u30ea\u3092\u30af\u30e9\u30b9\u30d1\u30b9\u306b\u8ffd\u52a0\u3057\u307e\u3059\u3002
\ No newline at end of file
diff --git a/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/wizard/NewCayenneWizard.java b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/wizard/NewCayenneWizard.java
new file mode 100644
index 0000000..18468b9
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/wizard/NewCayenneWizard.java
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.cayenne.wizard;
+
+
+import org.apache.click.eclipse.cayenne.editor.CayenneModelerLauncher;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.wizard.Wizard;
+import org.eclipse.ui.INewWizard;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.ide.IDE;
+
+/**
+ * This wizard creates new Cayenne mapping project.
+ * <p>
+ * Generates <tt>cayenne.xml</tt> which has the following contents:
+ * 
+ * <pre>
+ * &lt;?xml version="1.0" encoding="utf-8"?&gt;
+ * &lt;domains project-version="2.0"&gt;
+ * &lt;/domains&gt; </pre>
+ * 
+ * And open generated <tt>cayenne.xml</tt> by the Cayenne Modeler.
+ * 
+ * @author Naoki Takezoe
+ */
+public class NewCayenneWizard extends Wizard implements INewWizard {
+
+	private NewCayenneWizardPage page;
+	private ISelection selection;
+	
+	public NewCayenneWizard() {
+	}
+	
+	public void addPages() {
+		page = new NewCayenneWizardPage(selection);
+		addPage(page);
+	}
+
+
+	public boolean performFinish() {
+		IFile file = page.createNewFile();
+		if(file==null){
+			return false;
+		}
+		try {
+			IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
+			IDE.openEditor(page, file, CayenneModelerLauncher.EDITOR_ID);
+		} catch(PartInitException ex){
+			ex.printStackTrace();
+			return false;
+		}
+		return true;
+	}
+
+	public void init(IWorkbench workbench, IStructuredSelection selection) {
+		this.selection = selection;
+	}
+
+}
diff --git a/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/wizard/NewCayenneWizardPage.java b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/wizard/NewCayenneWizardPage.java
new file mode 100644
index 0000000..61ef150
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/wizard/NewCayenneWizardPage.java
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.cayenne.wizard;
+
+import java.io.InputStream;
+
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.ui.dialogs.WizardNewFileCreationPage;
+
+public class NewCayenneWizardPage extends WizardNewFileCreationPage {
+
+	public NewCayenneWizardPage(ISelection selection) {
+		super("wizardPage",(IStructuredSelection)selection);
+		setTitle("New Cayenne Mapping Project");
+		setDescription("Create the new Cayenne mapping project.");
+	}
+	
+	public void createControl(Composite parent) {
+		super.createControl(parent);
+		this.setFileName("cayenne.xml");
+	}
+	
+	protected InputStream getInitialContents() {
+		return NewCayenneWizardPage.class.getResourceAsStream("cayenne.xml");
+	}
+
+
+}
diff --git a/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/wizard/cayenne.xml b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/wizard/cayenne.xml
new file mode 100644
index 0000000..a618da4
--- /dev/null
+++ b/org.apache.click.eclipse.cayenne/src/org/apache/click/eclipse/cayenne/wizard/cayenne.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<domains project-version="3.0">
+</domains>
diff --git a/org.apache.click.eclipse.feature/.project b/org.apache.click.eclipse.feature/.project
new file mode 100644
index 0000000..b1e449f
--- /dev/null
+++ b/org.apache.click.eclipse.feature/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.apache.click.eclipse.feature</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.pde.FeatureBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.FeatureNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.apache.click.eclipse.feature/LICENSE.txt b/org.apache.click.eclipse.feature/LICENSE.txt
new file mode 100644
index 0000000..c11fcfe
--- /dev/null
+++ b/org.apache.click.eclipse.feature/LICENSE.txt
@@ -0,0 +1,383 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+=====================================================================
+
+Eclipse Public License -v 1.0
+
+(plain text)
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+    a) in the case of the initial Contributor, the initial code and
+       documentation distributed under this Agreement, and
+    b) in the case of each subsequent Contributor:
+    i) changes to the Program, and
+    ii) additions to the Program; 
+
+where such changes and/or additions to the Program originate from and
+are distributed by that particular Contributor. A Contribution 'originates'
+from a Contributor if it was added to the Program by such Contributor itself
+or anyone acting on such Contributor's behalf. Contributions do not include
+additions to the Program which: (i) are separate modules of software
+distributed in conjunction with the Program under their own license
+agreement, and (ii) are not derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are
+necessarily infringed by the use or sale of its Contribution alone or when
+combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement,
+including all Contributors.
+
+2. GRANT OF RIGHTS
+
+    a) Subject to the terms of this Agreement, each Contributor hereby grants
+       Recipient a non-exclusive, worldwide, royalty-free copyright license
+       to reproduce, prepare derivative works of, publicly display, publicly
+       perform, distribute and sublicense the Contribution of such Contributor,
+       if any, and such derivative works, in source code and object code form.
+    b) Subject to the terms of this Agreement, each Contributor hereby grants
+       Recipient a non-exclusive, worldwide, royalty-free patent license under
+       Licensed Patents to make, use, sell, offer to sell, import and otherwise
+       transfer the Contribution of such Contributor, if any, in source code
+       and object code form. This patent license shall apply to the combination
+       of the Contribution and the Program if, at the time the Contribution is
+       added by the Contributor, such addition of the Contribution causes such
+       combination to be covered by the Licensed Patents. The patent license
+       shall not apply to any other combinations which include the Contribution.
+       No hardware per se is licensed hereunder.
+    c) Recipient understands that although each Contributor grants the licenses
+       to its Contributions set forth herein, no assurances are provided by any
+       Contributor that the Program does not infringe the patent or other
+       intellectual property rights of any other entity. Each Contributor
+       disclaims any liability to Recipient for claims brought by any other
+       entity based on infringement of intellectual property rights or otherwise.
+       As a condition to exercising the rights and licenses granted hereunder,
+       each Recipient hereby assumes sole responsibility to secure any other
+       intellectual property rights needed, if any. For example, if a third
+       party patent license is required to allow Recipient to distribute the
+       Program, it is Recipient's responsibility to acquire that license before
+       distributing the Program.
+    d) Each Contributor represents that to its knowledge it has sufficient
+       copyright rights in its Contribution, if any, to grant the copyright
+       license set forth in this Agreement.
+
+    3. REQUIREMENTS
+
+    A Contributor may choose to distribute the Program in object code form under
+      its own license agreement, provided that:
+
+        a) it complies with the terms and conditions of this Agreement; and
+        b) its license agreement:
+        i) effectively disclaims on behalf of all Contributors all warranties
+           and conditions, express and implied, including warranties or conditions
+           of title and non-infringement, and implied warranties or conditions of
+           merchantability and fitness for a particular purpose;
+        ii) effectively excludes on behalf of all Contributors all liability for
+            damages, including direct, indirect, special, incidental and
+            consequential damages, such as lost profits;
+        iii) states that any provisions which differ from this Agreement are offered
+             by that Contributor alone and not by any other party; and
+        iv) states that source code for the Program is available from such
+            Contributor, and informs licensees how to obtain it in a reasonable
+            manner on or through a medium customarily used for software exchange. 
+
+    When the Program is made available in source code form:
+
+        a) it must be made available under this Agreement; and
+        b) a copy of this Agreement must be included with each copy of the Program. 
+
+    Contributors may not remove or alter any copyright notices contained within the
+    Program.
+
+    Each Contributor must identify itself as the originator of its Contribution,
+    if any, in a manner that reasonably allows subsequent Recipients to identify
+    the originator of the Contribution.
+
+    4. COMMERCIAL DISTRIBUTION
+
+    Commercial distributors of software may accept certain responsibilities with
+    respect to end users, business partners and the like. While this license is
+    intended to facilitate the commercial use of the Program, the Contributor who
+    includes the Program in a commercial product offering should do so in a manner
+    which does not create potential liability for other Contributors. Therefore,
+    if a Contributor includes the Program in a commercial product offering, such
+    Contributor ("Commercial Contributor") hereby agrees to defend and indemnify
+    every other Contributor ("Indemnified Contributor") against any losses,
+    damages and costs (collectively "Losses") arising from claims, lawsuits and
+    other legal actions brought by a third party against the Indemnified Contributor
+    to the extent caused by the acts or omissions of such Commercial Contributor
+    in connection with its distribution of the Program in a commercial product
+    offering. The obligations in this section do not apply to any claims or Losses
+    relating to any actual or alleged intellectual property infringement. In order
+    to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+    Contributor in writing of such claim, and b) allow the Commercial Contributor
+    to control, and cooperate with the Commercial Contributor in, the defense and
+    any related settlement negotiations. The Indemnified Contributor may participate
+    in any such claim at its own expense.
+
+    For example, a Contributor might include the Program in a commercial product
+    offering, Product X. That Contributor is then a Commercial Contributor. If that
+    Commercial Contributor then makes performance claims, or offers warranties
+    related to Product X, those performance claims and warranties are such
+    Commercial Contributor's responsibility alone. Under this section, the
+    Commercial Contributor would have to defend claims against the other
+    Contributors related to those performance claims and warranties, and if a court
+    requires any other Contributor to pay any damages as a result, the Commercial
+    Contributor must pay those damages.
+
+    5. NO WARRANTY
+
+    EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+    IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+    NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each
+    Recipient is solely responsible for determining the appropriateness of using
+    and distributing the Program and assumes all risks associated with its exercise
+    of rights under this Agreement , including but not limited to the risks and
+    costs of program errors, compliance with applicable laws, damage to or loss
+    of data, programs or equipment, and unavailability or interruption of operations.
+
+    6. DISCLAIMER OF LIABILITY
+
+    EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY
+    CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION
+    LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+    CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+    EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY
+    OF SUCH DAMAGES.
+
+    7. GENERAL
+
+    If any provision of this Agreement is invalid or unenforceable under
+    applicable law, it shall not affect the validity or enforceability of the
+    remainder of the terms of this Agreement, and without further action by
+    the parties hereto, such provision shall be reformed to the minimum extent
+    necessary to make such provision valid and enforceable.
+
+    If Recipient institutes patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Program itself
+    (excluding combinations of the Program with other software or hardware)
+    infringes such Recipient's patent(s), then such Recipient's rights granted
+    under Section 2(b) shall terminate as of the date such litigation is filed.
+
+    All Recipient's rights under this Agreement shall terminate if it fails to
+    comply with any of the material terms or conditions of this Agreement and
+    does not cure such failure in a reasonable period of time after becoming
+    aware of such noncompliance. If all Recipient's rights under this Agreement
+    terminate, Recipient agrees to cease use and distribution of the Program as
+    soon as reasonably practicable. However, Recipient's obligations under this
+    Agreement and any licenses granted by Recipient relating to the Program
+    shall continue and survive.
+
+    Everyone is permitted to copy and distribute copies of this Agreement, but
+    in order to avoid inconsistency the Agreement is copyrighted and may only
+    be modified in the following manner. The Agreement Steward reserves the
+    right to publish new versions (including revisions) of this Agreement from
+    time to time. No one other than the Agreement Steward has the right to
+    modify this Agreement. The Eclipse Foundation is the initial Agreement
+    Steward. The Eclipse Foundation may assign the responsibility to serve
+    as the Agreement Steward to a suitable separate entity. Each new version
+    of the Agreement will be given a distinguishing version number. The Program
+    (including Contributions) may always be distributed subject to the version
+    of the Agreement under which it was received. In addition, after a new version
+    of the Agreement is published, Contributor may elect to distribute the Program
+    (including its Contributions) under the new version. Except as expressly
+    stated in Sections 2(a) and 2(b) above, Recipient receives no rights or
+    licenses to the intellectual property of any Contributor under this Agreement,
+    whether expressly, by implication, estoppel or otherwise. All rights in the
+    Program not expressly granted under this Agreement are reserved.
+
+    This Agreement is governed by the laws of the State of New York and the
+    intellectual property laws of the United States of America. No party to
+    this Agreement will bring a legal action under this Agreement more than
+    one year after the cause of action arose. Each party waives its rights to
+    a jury trial in any resulting litigation.
diff --git a/org.apache.click.eclipse.feature/NOTICE.txt b/org.apache.click.eclipse.feature/NOTICE.txt
new file mode 100644
index 0000000..2f83966
--- /dev/null
+++ b/org.apache.click.eclipse.feature/NOTICE.txt
@@ -0,0 +1,13 @@
+ClickIDE
+Copyright 2010 The Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
+
+This product includes Spring Framework by SpringSource
+and released under the Apache 2.0 license.
+http://www.springsource.org/
+
+This product includes icons from Eclipse by The Eclipse Foundation
+and released under the Eclipse Public License
+http://www.eclipse.org/
diff --git a/org.apache.click.eclipse.feature/README.txt b/org.apache.click.eclipse.feature/README.txt
new file mode 100644
index 0000000..0018e20
--- /dev/null
+++ b/org.apache.click.eclipse.feature/README.txt
@@ -0,0 +1,74 @@
+
+Welcome to ClickIDE
+===================
+
+ClickIDE is an Eclipse plug-in for the developing Click web applications.
+
+ClickIDE is a sub project of Apache Click ant it is an open source project 
+licensed using the Apache license. 
+
+
+Installation
+============
+
+ClickIDE 2.1.0.x requires Eclipse 3.5.x and WTP 3.1.x.
+
+The easiest way to use ClickIDE is installing Eclipse IDE for Java EE Developers 
+and get a copy of ClickIDE from the downloads page. Unzip clickide-x.x.x.zip and 
+put 2 folders (plugins/ and features/) into your ECLIPSE_HOME. 
+
+
+Docmentation
+============
+
+Comprehensive HTML documentation is available online at:
+
+    http://incubator.apache.org/click/docs/click-ide.html
+
+
+Release Notes
+=============
+
+Detailed release notes are available here:
+
+    http://incubator.apache.org/click/docs/click-ide-roadmap-changes.html
+
+
+Build Information
+=================
+
+ClickIDE is built using the J2SE 1.5.0, Eclipse 3.5.x and Ant.
+At first, import following plugins as plugin project:
+
+ - org.apache.click.eclipse
+ - org.apache.click.eclipse.cayenne
+ - org.apache.click.eclipse.feature
+
+The Ant build script is located at : org.apache.click.eclipse.feature/clickide-build.xml.
+
+Note: Ant tasks have to be run in the same JRE as the workspace. To do this right click
+on clickide-build.xml -> Run As -> Ant Build ... -> JRE -> select the "Run in the same
+JRE as the workspace" radio button. 
+
+From the Eclipse IDE run org.apache.click.eclipse.feature/clickide-build.xml as follows:
+
+ 1) Run feature_export task
+ 
+   This task exports plugins to the dest directory using PDE and requires
+   an Eclipse environment.
+   
+   Note: Plugin exporting is executed as asynchronous job, so we have to wait for 
+   the completion of exporting before running the next task.
+ 
+ 2) Run append_files task
+ 
+   This task copies LICENSE.txt, NOTICE.txt and README.txt to
+   the exported directory.
+   
+ 3) Run create_zip task
+ 
+   This task makes a zip file to release.
+
+Then a plugin would be exported to org.apache.click.eclipse.feature/dest directory 
+as clickide-x.x.x.zip.
+
diff --git a/org.apache.click.eclipse.feature/build.properties b/org.apache.click.eclipse.feature/build.properties
new file mode 100644
index 0000000..430c487
--- /dev/null
+++ b/org.apache.click.eclipse.feature/build.properties
@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+bin.includes = feature.xml,\
+               feature.properties
diff --git a/org.apache.click.eclipse.feature/clickide-build.xml b/org.apache.click.eclipse.feature/clickide-build.xml
new file mode 100644
index 0000000..9edb639
--- /dev/null
+++ b/org.apache.click.eclipse.feature/clickide-build.xml
@@ -0,0 +1,86 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<project default="feature_export" name="build">
+	
+	<property name="dest.dir" value="dest" />
+	<property name="version" value="2.1.0.0" />
+	<property name="click.plugin" value="../org.apache.click.eclipse" />
+	<property name="cayenne.plugin" value="../org.apache.click.eclipse.cayenne" />
+
+	<!-- Macro for creating a SHA1 checksum -->
+	<macrodef name="digestMacro">
+		<attribute name="file"/>
+	    <sequential>
+	        <checksum file="@{file}" forceOverwrite="true" fileext=".md5"/>
+	        <checksum file="@{file}" forceOverwrite="true" algorithm="SHA1" fileext=".sha1"/>
+	    </sequential>
+	</macrodef>
+
+	<target name="feature_export">
+		<mkdir dir="${dest.dir}"/>
+		
+		<!-- Copy LICENSE and NOTICE to each plugin META-INF folder -->
+		<copy file="LICENSE.txt" todir="${click.plugin}/META-INF" />
+		<copy file="NOTICE.txt" todir="${click.plugin}/META-INF" />
+		<copy file="LICENSE.txt" todir="${cayenne.plugin}/META-INF" />
+		<copy file="NOTICE.txt" todir="${cayenne.plugin}/META-INF" />
+
+		<!-- Copy clickide sources to dest folder -->
+		<copy todir="${dest.dir}/clickide-${version}/src/org.apache.click.eclipse" overwrite="true">
+		    <fileset dir="${click.plugin}/src/">
+		        <exclude name="**/package.html"/>
+	    	</fileset>
+        </copy>
+
+		<!-- Copy clickide cayenne sources to dest folder -->
+		<copy todir="${dest.dir}/clickide-${version}/src/org.apache.click.eclipse.cayenne"  overwrite="true">
+		    <fileset dir="${cayenne.plugin}/src/">
+		        <exclude name="**/package.html"/>
+	    	</fileset>
+        </copy>
+
+		<pde.exportFeatures destination="${dest.dir}/clickide-${version}" exportSource="false"
+			exportType="directory" features="org.apache.click.eclipse.feature" useJARFormat="false"/>
+
+	</target>
+	
+	<target name="append_files">
+		<copy file="LICENSE.txt" todir="${dest.dir}/clickide-${version}" />
+		<copy file="NOTICE.txt" todir="${dest.dir}/clickide-${version}" />
+		<copy file="README.txt" todir="${dest.dir}/clickide-${version}" />
+	</target>
+	
+	<target name="create_zip">
+		<zip basedir="${dest.dir}/clickide-${version}" destfile="${dest.dir}/clickide-${version}.zip" />
+		<digestMacro file="${dest.dir}/clickide-${version}.zip"/>
+	</target>
+
+	<target name="clean">
+		<delete dir="${dest.dir}" />
+		<delete file="compile.org.apache.click.eclipse.feature.xml" />
+
+		<!-- Remove LICENSE and NOTICE from each plugin META-INF folder -->
+		<delete file="${click.plugin}/META-INF/LICENSE.txt" />
+		<delete file="${click.plugin}/META-INF/NOTICE.txt" />
+		<delete file="${cayenne.plugin}/META-INF/LICENSE.txt" />
+		<delete file="${cayenne.plugin}/META-INF/NOTICE.txt" />
+	</target>
+
+</project>
diff --git a/org.apache.click.eclipse.feature/feature.properties b/org.apache.click.eclipse.feature/feature.properties
new file mode 100644
index 0000000..d85b87c
--- /dev/null
+++ b/org.apache.click.eclipse.feature/feature.properties
@@ -0,0 +1,19 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+feature.name=ClickIDE
+feature.provider=Naoki Takezoe
diff --git a/org.apache.click.eclipse.feature/feature.xml b/org.apache.click.eclipse.feature/feature.xml
new file mode 100644
index 0000000..a7ccf61
--- /dev/null
+++ b/org.apache.click.eclipse.feature/feature.xml
@@ -0,0 +1,255 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<feature
+      id="org.apache.click.eclipse.feature"
+      label="%feature.name"
+      version="2.1.0.0"
+      provider-name="%feature.provider">
+
+   <description url="http://www.sunvolt.com/confluence/display/CLKT/ClickIDE">
+      ClickIDE is an Eclipse plug-in for Click. This is based on Eclipse and WTP, and provides some extended features for the web application development using Click.
+   </description>
+
+   <license url="http://www.apache.org/licenses/">
+      Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      &quot;License&quot; shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      &quot;Licensor&quot; shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      &quot;Legal Entity&quot; shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      &quot;control&quot; means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      &quot;You&quot; (or &quot;Your&quot;) shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      &quot;Source&quot; form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      &quot;Object&quot; form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      &quot;Work&quot; shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      &quot;Derivative Works&quot; shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      &quot;Contribution&quot; shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, &quot;submitted&quot;
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as &quot;Not a Contribution.&quot;
+
+      &quot;Contributor&quot; shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a &quot;NOTICE&quot; text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an &quot;AS IS&quot; BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+   </license>
+
+   <requires>
+      <import plugin="org.eclipse.core.runtime"/>
+      <import plugin="org.eclipse.wst.common.project.facet.core"/>
+      <import plugin="org.eclipse.jst.j2ee.web"/>
+      <import plugin="org.eclipse.jst.server.core"/>
+      <import plugin="org.eclipse.wst.server.core"/>
+      <import plugin="org.eclipse.wst.common.frameworks"/>
+      <import plugin="org.eclipse.jst.common.frameworks"/>
+      <import plugin="org.eclipse.jdt.core"/>
+      <import plugin="org.eclipse.core.resources"/>
+      <import plugin="org.eclipse.jst.j2ee"/>
+      <import plugin="org.eclipse.emf.common"/>
+      <import plugin="org.eclipse.emf.ecore"/>
+      <import plugin="org.eclipse.emf.ecore.xmi"/>
+      <import plugin="org.eclipse.jst.j2ee.core"/>
+      <import plugin="org.eclipse.jem.util"/>
+      <import plugin="org.eclipse.ui"/>
+      <import plugin="org.eclipse.jdt.ui"/>
+      <import plugin="org.eclipse.ui.ide"/>
+      <import plugin="org.eclipse.wst.sse.core"/>
+      <import plugin="org.eclipse.wst.sse.ui"/>
+      <import plugin="org.eclipse.ui.workbench.texteditor"/>
+      <import plugin="org.eclipse.jface.text"/>
+      <import plugin="org.eclipse.ui.editors"/>
+      <import plugin="org.eclipse.ui.forms"/>
+      <import plugin="org.eclipse.wst.xml.core"/>
+      <import plugin="org.eclipse.wst.xml.ui"/>
+      <import plugin="org.eclipse.ui.views"/>
+      <import plugin="org.eclipse.wst.validation"/>
+      <import plugin="org.eclipse.help"/>
+      <import plugin="org.eclipse.wst.html.ui"/>
+      <import plugin="org.eclipse.wst.html.core"/>
+   </requires>
+
+   <plugin
+         id="org.apache.click.eclipse"
+         download-size="0"
+         install-size="0"
+         version="2.1.0.0"
+         unpack="false"/>
+
+   <plugin
+         id="org.apache.click.eclipse.cayenne"
+         download-size="0"
+         install-size="0"
+         version="2.1.0.0"
+         unpack="false"/>
+
+</feature>
diff --git a/org.apache.click.eclipse/.classpath b/org.apache.click.eclipse/.classpath
new file mode 100644
index 0000000..2c8eeae
--- /dev/null
+++ b/org.apache.click.eclipse/.classpath
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/J2SE-1.5"/>
+	<classpathentry kind="con" path="org.eclipse.pde.core.requiredPlugins"/>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry exported="true" kind="lib" path="lib/velocity-1.5-dev.jar"/>
+	<classpathentry exported="true" kind="lib" path="lib/commons-collections-3.1.jar"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/org.apache.click.eclipse/.project b/org.apache.click.eclipse/.project
new file mode 100644
index 0000000..2af1998
--- /dev/null
+++ b/org.apache.click.eclipse/.project
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.apache.click.eclipse</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.ManifestBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.SchemaBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.pde.PluginNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.apache.click.eclipse/.settings/org.eclipse.jdt.core.prefs b/org.apache.click.eclipse/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..08c92d2
--- /dev/null
+++ b/org.apache.click.eclipse/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,57 @@
+#Tue Jul 21 00:11:51 JST 2009
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.5
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
+org.eclipse.jdt.core.compiler.problem.deprecation=warning
+org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled
+org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled
+org.eclipse.jdt.core.compiler.problem.discouragedReference=ignore
+org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore
+org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
+org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=error
+org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
+org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
+org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
+org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
+org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore
+org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning
+org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore
+org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore
+org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
+org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
+org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
+org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
+org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
+org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=ignore
+org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
+org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
+org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
+org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
+org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
+org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
+org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
+org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning
+org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
+org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore
+org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
+org.eclipse.jdt.core.compiler.problem.unusedImport=warning
+org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
+org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore
+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
+org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
+org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
+org.eclipse.jdt.core.compiler.source=1.5
diff --git a/org.apache.click.eclipse/.settings/org.eclipse.jdt.ui.prefs b/org.apache.click.eclipse/.settings/org.eclipse.jdt.ui.prefs
new file mode 100644
index 0000000..fb49c60
--- /dev/null
+++ b/org.apache.click.eclipse/.settings/org.eclipse.jdt.ui.prefs
@@ -0,0 +1,3 @@
+#Sat Jul 08 10:17:24 JST 2006
+eclipse.preferences.version=1
+internal.default.compliance=default
diff --git a/org.apache.click.eclipse/META-INF/MANIFEST.MF b/org.apache.click.eclipse/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..5fb7a3c
--- /dev/null
+++ b/org.apache.click.eclipse/META-INF/MANIFEST.MF
@@ -0,0 +1,98 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: %plugin.name
+Bundle-SymbolicName: org.apache.click.eclipse;singleton:=true
+Bundle-Version: 2.1.0.0
+Bundle-Activator: org.apache.click.eclipse.ClickPlugin
+Bundle-Vendor: %plugin.provider
+Bundle-Localization: plugin
+Require-Bundle: org.eclipse.core.runtime,
+ org.eclipse.wst.common.project.facet.core,
+ org.eclipse.jst.j2ee.web,
+ org.eclipse.jst.server.core,
+ org.eclipse.wst.server.core,
+ org.eclipse.wst.common.frameworks,
+ org.eclipse.jst.common.frameworks,
+ org.eclipse.jdt.core,
+ org.eclipse.core.resources,
+ org.eclipse.jst.j2ee,
+ org.eclipse.emf.common,
+ org.eclipse.emf.ecore,
+ org.eclipse.emf.ecore.xmi,
+ org.eclipse.jst.j2ee.core,
+ org.eclipse.jem.util,
+ org.eclipse.ui,
+ org.eclipse.jdt.ui,
+ org.eclipse.ui.ide,
+ org.eclipse.wst.sse.core,
+ org.eclipse.wst.sse.ui,
+ org.eclipse.ui.workbench.texteditor,
+ org.eclipse.jface.text,
+ org.eclipse.ui.editors,
+ org.eclipse.ui.forms,
+ org.eclipse.wst.xml.core,
+ org.eclipse.wst.xml.ui,
+ org.eclipse.ui.views,
+ org.eclipse.wst.validation,
+ org.eclipse.help,
+ org.eclipse.wst.html.ui,
+ org.eclipse.wst.html.core,
+ org.eclipse.wst.common.project.facet.ui,
+ org.apache.click.eclipse.cayenne
+Bundle-ActivationPolicy: lazy
+Bundle-ClassPath: lib/velocity-1.5-dev.jar,
+ lib/commons-collections-3.1.jar,
+ .
+Export-Package: org.apache.click.eclipse,
+ org.apache.click.eclipse.core.builder,
+ org.apache.click.eclipse.core.config,
+ org.apache.click.eclipse.core.facet,
+ org.apache.click.eclipse.core.validator,
+ org.apache.click.eclipse.preferences,
+ org.apache.click.eclipse.ui.actions,
+ org.apache.click.eclipse.ui.editor,
+ org.apache.click.eclipse.ui.editor.actions,
+ org.apache.click.eclipse.ui.editor.attrs,
+ org.apache.click.eclipse.ui.editor.forms,
+ org.apache.click.eclipse.ui.fieldassist,
+ org.apache.click.eclipse.ui.wizard,
+ org.apache.commons.collections,
+ org.apache.commons.collections.bag,
+ org.apache.commons.collections.bidimap,
+ org.apache.commons.collections.buffer,
+ org.apache.commons.collections.collection,
+ org.apache.commons.collections.comparators,
+ org.apache.commons.collections.functors,
+ org.apache.commons.collections.iterators,
+ org.apache.commons.collections.keyvalue,
+ org.apache.commons.collections.list,
+ org.apache.commons.collections.map,
+ org.apache.commons.collections.set,
+ org.apache.velocity,
+ org.apache.velocity.anakia,
+ org.apache.velocity.app,
+ org.apache.velocity.app.event,
+ org.apache.velocity.app.event.implement,
+ org.apache.velocity.app.tools,
+ org.apache.velocity.context,
+ org.apache.velocity.convert,
+ org.apache.velocity.exception,
+ org.apache.velocity.io,
+ org.apache.velocity.runtime,
+ org.apache.velocity.runtime.defaults,
+ org.apache.velocity.runtime.directive,
+ org.apache.velocity.runtime.exception,
+ org.apache.velocity.runtime.log,
+ org.apache.velocity.runtime.parser,
+ org.apache.velocity.runtime.parser.node,
+ org.apache.velocity.runtime.resource,
+ org.apache.velocity.runtime.resource.loader,
+ org.apache.velocity.runtime.visitor,
+ org.apache.velocity.servlet,
+ org.apache.velocity.texen,
+ org.apache.velocity.texen.ant,
+ org.apache.velocity.texen.defaults,
+ org.apache.velocity.texen.util,
+ org.apache.velocity.util,
+ org.apache.velocity.util.introspection
+Bundle-RequiredExecutionEnvironment: J2SE-1.5
diff --git a/org.apache.click.eclipse/build.properties b/org.apache.click.eclipse/build.properties
new file mode 100644
index 0000000..878ca3b
--- /dev/null
+++ b/org.apache.click.eclipse/build.properties
@@ -0,0 +1,34 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+source.. = src/
+output.. = bin/
+bin.includes = META-INF/,\
+               .,\
+               plugin.xml,\
+               icons/,\
+               toc.xml,\
+               plugin_ja.properties,\
+               plugin.properties,\
+               documentation/,\
+               lib/,\
+               schema/,\
+               click-2.1.0/,\
+               spring-2.5.6/,\
+               cayenne-3.0M6/
+src.includes = src/
+
diff --git a/org.apache.click.eclipse/cayenne-3.0M6/cayenne.xml b/org.apache.click.eclipse/cayenne-3.0M6/cayenne.xml
new file mode 100644
index 0000000..5f143e6
--- /dev/null
+++ b/org.apache.click.eclipse/cayenne-3.0M6/cayenne.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one
+   or more contributor license agreements.  See the NOTICE file
+   distributed with this work for additional information
+   regarding copyright ownership.  The ASF licenses this file
+   to you under the Apache License, Version 2.0 (the
+   "License"); you may not use this file except in compliance
+   with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing,
+   software distributed under the License is distributed on an
+   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+   KIND, either express or implied.  See the License for the
+   specific language governing permissions and limitations
+   under the License.
+-->
+<domains project-version="3.0">
+</domains>
diff --git a/org.apache.click.eclipse/cayenne-3.0M6/lib/ashwood-2.0.jar b/org.apache.click.eclipse/cayenne-3.0M6/lib/ashwood-2.0.jar
new file mode 100644
index 0000000..55fcc9b
--- /dev/null
+++ b/org.apache.click.eclipse/cayenne-3.0M6/lib/ashwood-2.0.jar
Binary files differ
diff --git a/org.apache.click.eclipse/cayenne-3.0M6/lib/cayenne-server-3.0M6.jar b/org.apache.click.eclipse/cayenne-3.0M6/lib/cayenne-server-3.0M6.jar
new file mode 100644
index 0000000..fdf0d05
--- /dev/null
+++ b/org.apache.click.eclipse/cayenne-3.0M6/lib/cayenne-server-3.0M6.jar
Binary files differ
diff --git a/org.apache.click.eclipse/cayenne-3.0M6/lib/commons-logging-1.1.1.jar b/org.apache.click.eclipse/cayenne-3.0M6/lib/commons-logging-1.1.1.jar
new file mode 100644
index 0000000..1deef14
--- /dev/null
+++ b/org.apache.click.eclipse/cayenne-3.0M6/lib/commons-logging-1.1.1.jar
Binary files differ
diff --git a/org.apache.click.eclipse/click-2.1.0/click.dtd b/org.apache.click.eclipse/click-2.1.0/click.dtd
new file mode 100644
index 0000000..18fe511
--- /dev/null
+++ b/org.apache.click.eclipse/click-2.1.0/click.dtd
@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one
+   or more contributor license agreements.  See the NOTICE file
+   distributed with this work for additional information
+   regarding copyright ownership.  The ASF licenses this file
+   to you under the Apache License, Version 2.0 (the
+   "License"); you may not use this file except in compliance
+   with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing,
+   software distributed under the License is distributed on an
+   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+   KIND, either express or implied.  See the License for the
+   specific language governing permissions and limitations
+   under the License.
+-->
+
+<!--
+     DTD for the Click Application Configuration File, Version 2.1
+
+     To support validation of your configuration file, include the following
+     DOCTYPE element at the beginning (after the "xml" declaration):
+
+     <!DOCTYPE click-app PUBLIC
+       "-//Apache Software Foundation//DTD Click Configuration 2.1//EN"
+       "http://click.apache.org/dtds/click_2_1.dtd">
+-->
+
+<!-- The Click Application (click.xml) Document Type Definition. -->
+<!ELEMENT click-app (pages*, headers?, format?, mode?, controls?, file-upload-service?, log-service?, template-service?)>
+  <!ATTLIST click-app charset CDATA #IMPLIED>
+  <!ATTLIST click-app locale CDATA #IMPLIED>
+
+  <!-- Application pages. -->
+  <!ELEMENT pages (page*, excludes*)>
+    <!ATTLIST pages package CDATA #IMPLIED>
+    <!ATTLIST pages automapping (true|false) "true">
+    <!ATTLIST pages autobinding (annotation|public|none) "annotation">
+
+    <!-- Page definition. -->
+    <!ELEMENT page (header*)>
+      <!ATTLIST page path CDATA #REQUIRED>
+      <!ATTLIST page classname CDATA #REQUIRED>
+
+    <!-- Excludes definition. -->
+    <!ELEMENT excludes (#PCDATA)>
+      <!ATTLIST excludes pattern CDATA #REQUIRED>
+
+  <!-- Application default page headers. -->
+  <!ELEMENT headers (header*)>
+
+    <!-- Header definition. -->
+    <!ELEMENT header (#PCDATA)>
+      <!ATTLIST header name CDATA #REQUIRED>
+      <!ATTLIST header value CDATA #REQUIRED>
+      <!ATTLIST header type (String|Integer|Date) "String">
+
+  <!-- Page template formatter class. An new format object added to
+       the Velocity context under the key: "format". -->
+  <!ELEMENT format (#PCDATA)>
+   <!ATTLIST format classname CDATA #FIXED "org.apache.click.util.Format">
+
+  <!-- Application mode, which configures logging and caching. -->
+  <!ELEMENT mode (#PCDATA)>
+   <!ATTLIST mode value (production|profile|development|debug|trace) "development">
+
+  <!-- Application control objects. -->
+  <!ELEMENT controls (control*, control-set*)>
+
+    <!-- Deployable control class. -->
+    <!ELEMENT control (#PCDATA)>
+      <!ATTLIST control classname CDATA #REQUIRED>
+
+    <!-- Deployable Third Party Set of Controls -->
+    <!ELEMENT control-set (#PCDATA)>
+      <!ATTLIST control-set name CDATA #REQUIRED>
+
+  <!-- File Upload Service. -->
+  <!ELEMENT file-upload-service (property*)>
+   <!ATTLIST file-upload-service classname CDATA #FIXED "org.apache.click.service.FileUploadService">
+
+    <!-- Property definition. -->
+    <!ELEMENT property (#PCDATA)>
+      <!ATTLIST property name CDATA #REQUIRED>
+      <!ATTLIST property value CDATA #REQUIRED>
+
+  <!-- Log Service. -->
+  <!ELEMENT log-service (property*)>
+   <!ATTLIST log-service classname CDATA #FIXED "org.apache.click.service.ConsoleLogService">
+
+  <!-- Template Service class. -->
+  <!ELEMENT template-service (property*)>
+   <!ATTLIST template-service classname CDATA #FIXED "org.apache.click.service.VelocityTemplateService">
diff --git a/org.apache.click.eclipse/click-2.1.0/click.xml b/org.apache.click.eclipse/click-2.1.0/click.xml
new file mode 100644
index 0000000..daf6087
--- /dev/null
+++ b/org.apache.click.eclipse/click-2.1.0/click.xml
@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one
+   or more contributor license agreements.  See the NOTICE file
+   distributed with this work for additional information
+   regarding copyright ownership.  The ASF licenses this file
+   to you under the Apache License, Version 2.0 (the
+   "License"); you may not use this file except in compliance
+   with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing,
+   software distributed under the License is distributed on an
+   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+   KIND, either express or implied.  See the License for the
+   specific language governing permissions and limitations
+   under the License.
+-->
+<!DOCTYPE click-app PUBLIC
+  "-//Apache Software Foundation//DTD Click Configuration 2.1//EN"
+  "http://click.apache.org/dtds/click_2_1.dtd">
+
+<click-app charset="UTF-8">
+
+  <pages package="${rootPackage}" autobinding="annotation"/>
+
+  <mode value="profile"/>
+
+</click-app>
diff --git a/org.apache.click.eclipse/click-2.1.0/lib/click-2.1.0.jar b/org.apache.click.eclipse/click-2.1.0/lib/click-2.1.0.jar
new file mode 100644
index 0000000..7261f80
--- /dev/null
+++ b/org.apache.click.eclipse/click-2.1.0/lib/click-2.1.0.jar
Binary files differ
diff --git a/org.apache.click.eclipse/click-2.1.0/lib/click-extras-2.1.0.jar b/org.apache.click.eclipse/click-2.1.0/lib/click-extras-2.1.0.jar
new file mode 100644
index 0000000..0ea9b57
--- /dev/null
+++ b/org.apache.click.eclipse/click-2.1.0/lib/click-extras-2.1.0.jar
Binary files differ
diff --git a/org.apache.click.eclipse/click-2.1.0/lib/click-mock-2.1.0.jar b/org.apache.click.eclipse/click-2.1.0/lib/click-mock-2.1.0.jar
new file mode 100644
index 0000000..fa647a8
--- /dev/null
+++ b/org.apache.click.eclipse/click-2.1.0/lib/click-mock-2.1.0.jar
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/javadoc.html b/org.apache.click.eclipse/documentation/javadoc.html
new file mode 100644
index 0000000..0c83a05
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/javadoc.html
@@ -0,0 +1,79 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" 
+"http://www.w3.org/TR/html4/loose.dtd">
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one
+   or more contributor license agreements.  See the NOTICE file
+   distributed with this work for additional information
+   regarding copyright ownership.  The ASF licenses this file
+   to you under the Apache License, Version 2.0 (the
+   "License"); you may not use this file except in compliance
+   with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing,
+   software distributed under the License is distributed on an
+   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+   KIND, either express or implied.  See the License for the
+   specific language governing permissions and limitations
+   under the License.
+-->
+<html>
+<head>
+    <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"/>
+    <meta name="Author" content="Malcolm Edgar"/>
+    <meta name="description" lang="en" content="Apache Click Java web application framework"/>
+    <meta name="keywords" lang="en" content="Apache Click, Click Framework, Java, JEE, J2EE, web application framework, open source"/>
+    <title>Apache Click</title>
+    <link rel="stylesheet" type="text/css" href="../help.css"/>
+    <style type="text/css">
+        .change {
+            margin-bottom: 0.75em;
+        }
+
+    </style>
+</head>
+<body>
+
+<h1>Click Javadoc</h1>
+
+<p/>
+Click is distributed as three separate libraries <em>click.jar</em>, <em>click-extras.jar</em> and <em>click-mock.jar</em>.
+<p/>
+The Javadoc API of these libraries is provided below:
+
+<ul style="margin-bottom:3em;">
+    <li class="change" style="padding-bottom:0.25em;">
+        <a  target='topic' href='click-api/overview-summary.html' title=' Click Javadoc API'>Click API</a> 
+        &nbsp; - &nbsp; <i>(click.jar)</i>
+        <p> 
+        Provides the Core API and consists of everything you need to build a Click web application. 
+        </p>
+    </li>
+    <li class="change" style="padding-bottom:0.25em;">
+        <a target='topic' href='click-api/org/apache/click/control/package-summary.html' title=' Controls Javadoc API'>Controls API</a>
+        &nbsp; - &nbsp;  <i>(click.jar)</i>
+        <p> 
+        Provides the Core Controls, and provides a short description of each control and corresponding HTML element. 
+        </p>
+    </li>
+    <li class="change" style="padding-bottom:0.25em;">
+        <a  target='topic' href='extras-api/overview-summary.html' title=' Click Extras Javadoc API'>Extras API</a>
+        &nbsp; - &nbsp;  <i>(click-extras.jar)</i>
+        <p> 
+        Provides components that are tailored to specific technologies, such as a Hibernate, Spring and Cayenne.
+        Extras also include many Controls including IntegerField, DoubleField and DateField. You will also find Filters which 
+        can improve your application performance.
+        </p>
+    </li style="padding-bottom:0.25em;">
+        <li class="change">
+        <a target='topic' href='mock-api/org/apache/click/package-summary.html' title=' Mock Javadoc API'>Mock API</a>
+        &nbsp; - &nbsp;  <i>(click-mock.jar)</i>
+        <p>
+        Provides a library for testing Click Pages and Controls, independent of a Servlet container such as Tomcat or Jetty.
+        </p>
+    </li>
+</ul>
+
+You can find these libraries under the <em>/dist</em> folder in the Click distribution you downloaded.
+<p/>
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch01.html b/org.apache.click.eclipse/documentation/user-guide/ch01.html
new file mode 100644
index 0000000..ad969ab
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch01.html
@@ -0,0 +1,74 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>Chapter&nbsp;1.&nbsp;Introduction to Apache Click</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="index.html" title="Apache Click"><link rel="prev" href="index.html" title="Apache Click"><link rel="next" href="ch01s02.html" title="1.2.&nbsp;Control Listener Type 1 Example"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;1.&nbsp;Introduction to Apache Click</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="index.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch01s02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;1.&nbsp;Introduction to Apache Click"><div class="titlepage"><div><div><h2 class="title"><a name="chapter-introduction"></a>Chapter&nbsp;1.&nbsp;Introduction to Apache Click</h2></div></div></div><div class="toc"><dl><dt><span class="sect1"><a href="ch01.html#hello-world">1.1. Hello World Example</a></span></dt><dt><span class="sect1"><a href="ch01s02.html">1.2. Control Listener Type 1 Example</a></span></dt><dt><span class="sect1"><a href="ch01s03.html">1.3. Control Listener Type 2 Example</a></span></dt><dt><span class="sect1"><a href="ch01s04.html">1.4. Simple Table Example</a></span></dt><dt><span class="sect1"><a href="ch01s05.html">1.5. Advanced Table Example</a></span></dt><dt><span class="sect1"><a href="ch01s06.html">1.6. Simple Form Example</a></span></dt><dt><span class="sect1"><a href="ch01s07.html">1.7. Advanced Form Example</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch01s07.html#form-layout">1.7.1. Form Layout</a></span></dt></dl></dd></dl></div><p>Apache Click is a simple JEE web application framework for commercial
+  Java developers.
+  </p><p>Apache Click is an open source project, licensed under the
+  <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../LICENSE.txt" target="_blank"><em class="citetitle">Apache license</em>
+  </a>.
+  </p><p>Click uses an event based programming model for processing Servlet
+  requests and <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../velocity/velocity.html" target="_blank">Velocity</a> for
+  rendering the response. (Note other template engines such as
+  <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/jsp/" target="_blank">JSP</a> and
+  <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://freemarker.sourceforge.net/" target="_blank">Freemarker</a> are also
+  supported)
+  </p><p>This framework uses a single servlet, called
+  <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/ClickServlet.html" target="_blank">ClickServlet</a>,
+  to act as a request dispatcher. When a request arrives ClickServlet creates
+  a <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html" target="_blank">Page</a>
+  object to process the request and then uses the page's Velocity template to
+  render the results.
+  </p><p>Pages provide a simple thread safe programming environment, with a new
+  page instance created for each servlet request.
+  </p><p>Possibly the best way to see how Click works is to dive right in and
+  look at some examples. (The examples are also available online at
+  <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://www.avoka.com/click-examples/" target="_blank">http://www.avoka.com/click-examples/</a>
+  under the menu "Intro Examples".)
+  </p><div class="sect1" title="1.1.&nbsp;Hello World Example"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="hello-world"></a>1.1.&nbsp;Hello World Example</h2></div></div></div><p>A Hello World example in Click would look something like this.
+    </p><p>First we create a <code class="classname">HelloWorld</code> page class:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">package</span> <span class="symbol">examples.page</span>;
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">import</span> java.util.Date;
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">import</span> org.apache.click.Page;
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> HelloWorld <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> Date time = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Date(); <a class="co" name="co-hello-world-date" href="ch01.html#ca-hello-world-date"><img src="images/callouts/1.gif" alt="1" border="0"></a>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> HelloWorld() {
+        addModel(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"time"</span>, time); <a class="co" name="co-hello-world-addmodel" href="ch01.html#ca-hello-world-addmodel"><img src="images/callouts/2.gif" alt="2" border="0"></a>
+    }
+
+}</pre><div class="calloutlist"><table border="0" summary="Callout list"><tr xmlns:fo="http://www.w3.org/1999/XSL/Format"><td valign="top" align="left"><a name="ca-hello-world-date"></a><a href="#co-hello-world-date"><img src="images/callouts/1.gif" alt="1" border="0"></a> </td><td valign="top" align="left"><p>Assign a new Date instance to the <code class="literal">time</code> variable.
+        </p></td></tr><tr xmlns:fo="http://www.w3.org/1999/XSL/Format"><td valign="top" align="left"><a name="ca-hello-world-addmodel"></a><a href="#co-hello-world-addmodel"><img src="images/callouts/2.gif" alt="2" border="0"></a> </td><td valign="top" align="left"><p>Add the <code class="literal">time</code> variable to the Page model under
+        the name <code class="varname">"time"</code>. Click ensures all objects added
+        to the Page model is automatically available in the Page template.
+        </p></td></tr></table></div><p>Next we have a page template <code class="varname">hello-world.htm</code>,
+    <a class="indexterm" name="d0e101"></a>
+    where we can access the Page's <code class="literal">time</code> variable using the
+    reference <code class="varname">$time</code>:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;h2&gt;</span>Hello World<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/h2&gt;</span>
+
+    Hello world from Click at <code class="varname">$time</code>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>Click is smart enough to figure out that the <code class="classname">HelloWorld</code>
+    page class maps to the template <code class="varname">hello-world.htm</code>. We only
+    have to inform Click of the <span class="package">package</span> of the HelloWorld
+    class, in this case <span class="symbol">examples.page</span>. We do that through the
+    <a class="link" href="ch04s02.html" title="4.2.&nbsp;Application Configuration">click.xml</a> configuration
+    file which allows Click to map <code class="varname">hello-world.htm</code> requests
+    to the <code class="classname">examples.page.HelloWorld</code> page class.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="symbol">examples.page</span>"/&gt;
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>At runtime the following sequence of events occur. The ClickSerlvet
+    maps a GET <code class="varname">hello-world.htm</code> request to our page class
+    <code class="classname">example.page.HelloWorld</code> and creates a new instance.
+    The HelloWorld page creates a new private <span class="emphasis"><em>Date</em></span> object,
+    which is added to the page's model under the name <code class="varname">time</code>.
+    </p><p>The page model is then merged with the template which substitutes
+    the <code class="varname">$time</code> reference with the <span class="emphasis"><em>Date</em></span>
+    object. Velocity then renders the merged template as:
+    </p><div class="figure"><a name="hello-world-screenshot"></a><div class="figure-contents"><span class="inlinemediaobject"><img src="images/introduction/hello-world-screenshot.png" alt="Hello World Screenshot"></span></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;1.1.&nbsp;Hello World Screenshot</i></p></div><br class="figure-break"></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="index.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch01s02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Apache Click&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;1.2.&nbsp;Control Listener Type 1 Example</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch01s02.html b/org.apache.click.eclipse/documentation/user-guide/ch01s02.html
new file mode 100644
index 0000000..a703002
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch01s02.html
@@ -0,0 +1,67 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>1.2.&nbsp;Control Listener Type 1 Example</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch01.html" title="Chapter&nbsp;1.&nbsp;Introduction to Apache Click"><link rel="prev" href="ch01.html" title="Chapter&nbsp;1.&nbsp;Introduction to Apache Click"><link rel="next" href="ch01s03.html" title="1.3.&nbsp;Control Listener Type 2 Example"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">1.2.&nbsp;Control Listener Type 1 Example</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch01.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;1.&nbsp;Introduction to Apache Click</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch01s03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="1.2.&nbsp;Control Listener Type 1 Example"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="control-listener-type-1"></a>1.2.&nbsp;Control Listener Type 1 Example</h2></div></div></div><p>Click includes a library of <a class="link" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Controls">Controls</a>
+    which provide user interface functionality.
+    </p><p>One of the commonly used controls is the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/ActionLink.html" target="_blank">ActionLink</a>,
+    which you can use to have an HTML link call a method on a Page object.
+    For example:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> ControlListenerType1Page <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/* Set the listener to this object's "onLinkClick" method. */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> ActionLink myLink = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> ActionLink(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">this</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"onLinkClick"</span>); <a class="co" name="co-bindable" href="ch01s02.html#ca-bindable"><img src="images/callouts/1.gif" alt="1" border="0"></a>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> String msg;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// --------------------------------------------------------- Event Handlers</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * Handle the ActionLink control click event.
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onLinkClick() {
+        msg = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"ControlListenerPage#"</span> + hashCode()
+            + <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">" object method &lt;tt&gt;onLinkClick()&lt;/tt&gt; invoked."</span>;
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> true;
+    }
+
+}</pre><div class="calloutlist"><table border="0" summary="Callout list"><tr xmlns:fo="http://www.w3.org/1999/XSL/Format"><td valign="top" align="left"><a name="ca-bindable"></a><a href="#co-bindable"><img src="images/callouts/1.gif" alt="1" border="0"></a> </td><td valign="top" align="left"><p>Variables annotated with <code class="literal">@Bindable</code>
+        is a short-hand way of instructing Click to automatically bind request
+        parameters to Page variables. Additionally these variables will be
+        automatically added to the Page model. For more information please see the
+        section <a class="link" href="ch02s03.html" title="2.3.&nbsp;Request Parameter Auto Binding">Request Parameter Auto Binding</a>.
+        </p></td></tr></table></div><p>In the Page class we create an ActionLink called
+    <code class="varname">myLink</code> and define the control's listener to be the page
+    method <code class="methodname">onLinkClick()</code>. When a user clicks on
+    <code class="varname">myLink</code> control it will invoke the listener method
+    <code class="methodname">onLinkClick()</code>.
+    </p><p>In Click a control listener method can have any name but it must
+    return a boolean value. The boolean return value specifies whether
+    processing of page events should continue. This control listener pattern
+    provides a short hand way for wiring up action listener methods without
+    having to define anonymous inner classes.
+    </p><p>The advantage of this style of control listener binding is that you
+    have to write fewer lines of code. The disadvantage of this type of control
+    listener binding is that no compile time safety is provided, and you miss
+    out on the compiler refactoring capabilities provided with modern IDEs.
+    </p><p>Back to our example, in the page template we define an HTML link and
+    have the <code class="varname">myLink</code> control render the link's href attribute:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;link</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/css"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">rel</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"stylesheet"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">href</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"style.css"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/link&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+  
+  Click myLink control <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;a</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">href</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><code class="varname">$myLink.href</code>"&gt;here<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/a&gt;</span>.
+
+  <span class="command"><strong>#if</strong></span> (<code class="varname">$msg</code>)
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;div</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"msgDiv"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span> <code class="varname">$msg</code> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/div&gt;</span>
+  <span class="command"><strong>#end</strong></span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>At runtime this page would be rendered as:</p><div class="literallayout"><p>Click&nbsp;myLink&nbsp;control&nbsp;<code class="varname">here</code>.</p></div><p>When a user clicks on the link the <code class="methodname">onLinkClick()</code>
+    method is invoked. This method then creates the <code class="varname">msg</code> model
+    value, which is rendered in the page as:
+    </p><div class="literallayout"><p>Click&nbsp;myLink&nbsp;control&nbsp;<code class="varname">here</code>.<br>
+<br>
+<code class="computeroutput">ControlListenerPage#12767107&nbsp;object&nbsp;method&nbsp;onLinkClick()&nbsp;invoked.</code></p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch01.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch01s03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;1.&nbsp;Introduction to Apache Click&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;1.3.&nbsp;Control Listener Type 2 Example</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch01s03.html b/org.apache.click.eclipse/documentation/user-guide/ch01s03.html
new file mode 100644
index 0000000..21d1903
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch01s03.html
@@ -0,0 +1,56 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>1.3.&nbsp;Control Listener Type 2 Example</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch01.html" title="Chapter&nbsp;1.&nbsp;Introduction to Apache Click"><link rel="prev" href="ch01s02.html" title="1.2.&nbsp;Control Listener Type 1 Example"><link rel="next" href="ch01s04.html" title="1.4.&nbsp;Simple Table Example"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">1.3.&nbsp;Control Listener Type 2 Example</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch01s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;1.&nbsp;Introduction to Apache Click</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch01s04.html">Next</a></td></tr></table><hr></div><div class="sect1" title="1.3.&nbsp;Control Listener Type 2 Example"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="control-listener-type-2"></a>1.3.&nbsp;Control Listener Type 2 Example</h2></div></div></div><p>The second type of control listener binding uses the 
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/ActionListener.html" target="_blank">ActionListener</a>
+    interface to provide compile time safety. This compile time binding also 
+    supports code refactoring using modern IDE tools.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> ControlListenerType2Page <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/* Public scope controls are automatically added to the page. */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> ActionLink myLink = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> ActionLink();
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> String msg;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// ------------------------------------------------------------ Constructor</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * Create a new Page instance.
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> ControlListenerType2Page() {
+        myLink.setActionListener(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> ActionListener() {
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onAction(Control control) {
+                 msg = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"ControlListenerPage#"</span> + hashCode()
+                 + <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">" object method &lt;tt&gt;onAction()&lt;/tt&gt; invoked."</span>;
+
+             <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> true;
+            }
+        });
+    }
+    
+}</pre><p>In the Page class we create an ActionLink called
+    <code class="varname">myLink</code>. In the Page constructor we set the control's
+    action listener to an annonymous inner class which implements the 
+    <code class="methodname">onAction()</code>. When a user clicks on
+    <code class="varname">myLink</code> control it will invoke the action listener method
+    <code class="methodname">onAction()</code>.
+    </p><p>As with our previous example, in the page template we define a HTML link and
+    have the <code class="varname">myLink</code> control render the link's href attribute:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;link</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/css"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">rel</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"stylesheet"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">href</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"style.css"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/link&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+  
+  Click myLink control <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;a</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">href</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><code class="varname">$myLink.href</code>"&gt;here<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/a&gt;</span>.
+
+  <span class="command"><strong>#if</strong></span> (<code class="varname">$msg</code>)
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;div</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"msgDiv"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span> <code class="varname">$msg</code> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/div&gt;</span>
+  <span class="command"><strong>#end</strong></span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>At runtime this page would be rendered as:</p><div class="literallayout"><p>Click&nbsp;myLink&nbsp;control&nbsp;<code class="varname">here</code>.</p></div><p>When a user clicks on the link the <code class="methodname">onAction()</code>
+    method is invoked. This method then creates the <code class="varname">msg</code> model
+    value, which is rendered in the page as:
+    </p><div class="literallayout"><p>Click&nbsp;myLink&nbsp;control&nbsp;<code class="varname">here</code>.<br>
+<br>
+<code class="computeroutput">ControlListenerPage#12767107&nbsp;object&nbsp;method&nbsp;onAction()&nbsp;invoked.</code></p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch01s02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch01s04.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">1.2.&nbsp;Control Listener Type 1 Example&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;1.4.&nbsp;Simple Table Example</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch01s04.html b/org.apache.click.eclipse/documentation/user-guide/ch01s04.html
new file mode 100644
index 0000000..36524bf
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch01s04.html
@@ -0,0 +1,63 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>1.4.&nbsp;Simple Table Example</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch01.html" title="Chapter&nbsp;1.&nbsp;Introduction to Apache Click"><link rel="prev" href="ch01s03.html" title="1.3.&nbsp;Control Listener Type 2 Example"><link rel="next" href="ch01s05.html" title="1.5.&nbsp;Advanced Table Example"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">1.4.&nbsp;Simple Table Example</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch01s03.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;1.&nbsp;Introduction to Apache Click</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch01s05.html">Next</a></td></tr></table><hr></div><div class="sect1" title="1.4.&nbsp;Simple Table Example"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="simple-table"></a>1.4.&nbsp;Simple Table Example</h2></div></div></div><p>One of the most useful Click controls is the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Table.html" target="_blank">Table</a>
+    control.
+    </p><p>An example usage of the Table control in a customers Page is provided
+    below:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> SimpleTablePage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> Table table = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Table();
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// -------------------------------------------------------- Constructor</span>
+     
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> SimpleTablePage() {
+        table.setClass(Table.CLASS_ITS);
+        
+        table.addColumn(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Column(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"id"</span>));
+        table.addColumn(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Column(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"name"</span>));
+        table.addColumn(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Column(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"email"</span>));
+        table.addColumn(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Column(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"investments"</span>));
+    }
+    
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// ----------------------------------------------------- Event Handlers</span>
+     
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see Page#onRender()
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Override</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onRender() {
+        List list = getCustomerService().getCustomersSortedByName(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="lit">10</span>);
+        table.setRowList(list); 
+    }
+}</pre><p>In this Page code example a Table control is declared, we set the
+    table's HTML class, and then define a number of table
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Column.html" target="_blank">Column</a>
+    objects. In the column definitions we specify the name of the column in the
+    constructor, which is used for the table column header and also to specify
+    the row object property to render.
+    </p><p>The last thing we need to do is populate the table with data. To do
+    this we override the Page onRender() method and set the table row list
+    before it is rendered.
+    </p><p>In our Page template we simply reference the <code class="varname">$table</code>
+    object which is rendered when its <code class="methodname">toString()</code> method
+    is called.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <code class="varname">$headElements</code>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+    <code class="varname">$table</code>
+
+    <code class="varname">$jsElements</code>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>Note from the example above that we specify the <code class="varname">$headElements</code>
+    reference so that the table can include any HEAD elements, which includes Css
+    imports and styles, in the header. Also note we specify the
+    <code class="varname">$jsElements</code> reference which include any JavaScript imports
+    and scripts at the bottom. At runtime Click automatically makes the variables
+    <code class="varname">$headElements</code> and <code class="varname">$jsElements</code> available
+    to the template.
+    </p><p>At runtime the Table would be rendered in the page as:</p><div class="figure"><a name="simple-table-image"></a><div class="figure-contents"><div class="mediaobject"><img src="images/introduction/simple-table.png" alt="Simple Table"></div></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;1.2.&nbsp;Simple Table</i></p></div><br class="figure-break"></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch01s03.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch01s05.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">1.3.&nbsp;Control Listener Type 2 Example&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;1.5.&nbsp;Advanced Table Example</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch01s05.html b/org.apache.click.eclipse/documentation/user-guide/ch01s05.html
new file mode 100644
index 0000000..802015e
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch01s05.html
@@ -0,0 +1,103 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>1.5.&nbsp;Advanced Table Example</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch01.html" title="Chapter&nbsp;1.&nbsp;Introduction to Apache Click"><link rel="prev" href="ch01s04.html" title="1.4.&nbsp;Simple Table Example"><link rel="next" href="ch01s06.html" title="1.6.&nbsp;Simple Form Example"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">1.5.&nbsp;Advanced Table Example</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch01s04.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;1.&nbsp;Introduction to Apache Click</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch01s06.html">Next</a></td></tr></table><hr></div><div class="sect1" title="1.5.&nbsp;Advanced Table Example"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="advanced-table"></a>1.5.&nbsp;Advanced Table Example</h2></div></div></div><p>The Table control also provides support for:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>automatic rendering</p></li><li class="listitem"><p>column formatting and custom rendering</p></li><li class="listitem"><p>automatic pagination</p></li><li class="listitem"><p>link control support</p></li></ul></div><p>A more advanced Table example is provided below:</p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> CustomerPage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> Table table = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Table();
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> PageLink editLink = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> PageLink(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Edit"</span>, EditCustomer.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>);
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> ActionLink deleteLink = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> ActionLink(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Delete"</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">this</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"onDeleteClick"</span>);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// ------------------------------------- Constructor</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> CustomersPage() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Setting Page to stateful to preserve Table sort and paging state while</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// editing customers</span>
+        setStateful(true); <a class="co" name="co-stateful-table" href="ch01s05.html#ca-stateful-table"><img src="images/callouts/1.gif" alt="1" border="0"></a>
+
+        table.setClass(Table.CLASS_ITS);
+        table.setPageSize(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="lit">10</span>);
+        table.setShowBanner(true);
+        table.setSortable(true);
+
+        table.addColumn(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Column(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"id"</span>));
+
+        table.addColumn(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Column(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"name"</span>));
+        
+        Column column = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Column(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"email"</span>);
+        column.setAutolink(true);
+        column.setTitleProperty(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"name"</span>);
+        table.addColumn(column);
+        
+        table.addColumn(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Column(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"investments"</span>));
+        
+        editLink.setImageSrc(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/images/table-edit.png"</span>);
+        editLink.setTitle(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Edit customer details"</span>);
+        editLink.setParameter(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"referrer"</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/introduction/advanced-table.htm"</span>);
+        
+        deleteLink.setImageSrc(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/images/table-delete.png"</span>);
+        deleteLink.setTitle(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Delete customer record"</span>);
+        deleteLink.setAttribute(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"onclick"</span>,
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"return window.confirm('Are you sure you want to delete this record?');"</span>);
+
+        column = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Column(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Action"</span>);
+        column.setTextAlign(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"center"</span>);
+        AbstractLink[] links = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> AbstractLink[] { editLink, deleteLink };
+        column.setDecorator(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> LinkDecorator(table, links, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"id"</span>));
+        column.setSortable(false);
+        table.addColumn(column);
+    }
+    
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// ---------------------------------- Event Handlers</span>
+         
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * Handle the delete row click event.
+     */</span>    
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onDeleteClick() {
+        Integer id = deleteLink.getValueInteger();
+        getCustomerService().deleteCustomer(id);
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> true;
+    }
+    
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see Page#onRender()
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Override</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onRender() {
+        List list = getCustomerService().getCustomersByName();
+        table.setRowList(list);
+    }
+}</pre><div class="calloutlist"><table border="0" summary="Callout list"><tr xmlns:fo="http://www.w3.org/1999/XSL/Format"><td valign="top" align="left"><a name="ca-stateful-table"></a><a href="#co-stateful-table"><img src="images/callouts/1.gif" alt="1" border="0"></a> </td><td valign="top" align="left"><p>Setting Page to stateful instructs Click to store the Page in the
+        <a class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpSession.html" target="_blank">HttpSession</a>.
+        This ensures the Table's sort and paging state is preserved while editing
+        customers. See the <a class="link" href="ch02s08.html" title="2.8.&nbsp;Stateful Pages">Stateful Page</a>
+        section for more details.
+        </p></td></tr></table></div><p>In this Page code example a Table control is declared and a number of
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Column.html" target="_blank">Column</a>
+    objects are added. An editLink
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/PageLink.html" target="_blank">PageLink</a>
+    control is used as decorator for the "Action" column. This control navigates
+    to the <code class="classname">EditCustomer</code> page. A deleteLink
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/ActionLink.html" target="_blank">ActionLink</a>
+    control is also used as a decorator for the "Action" column. This control will
+    invoke the Page <code class="methodname">onDeleteClick()</code> method when it is
+    clicked. Finally we have the Page <code class="methodname">onRender()</code> method
+    which is used to populate the Table control with rows before it is rendered.
+    </p><p>In our Page template we simply reference the <code class="varname">$table</code>
+    object which is rendered when its <code class="methodname">toString()</code> method
+    is called.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <code class="varname">$headElements</code>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+    <code class="varname">$table</code>
+
+    <code class="varname">$jsElements</code>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>At runtime the Table would be rendered in the page as:</p><div class="figure"><a name="advanced-table-image"></a><div class="figure-contents"><div class="mediaobject"><img src="images/introduction/advanced-table.png" alt="Advanced Table"></div></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;1.3.&nbsp;Advanced Table</i></p></div><br class="figure-break"><p>In this example, clicking on the Edit link will navigate the user to
+    the <code class="classname">EditCustomer</code> page where the selected customer
+    can be edited. When the user click on the Delete link, the
+    <code class="methodname">onDeleteClick()</code> method will be called on the Page
+    deleting the customer record.
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch01s04.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch01s06.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">1.4.&nbsp;Simple Table Example&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;1.6.&nbsp;Simple Form Example</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch01s06.html b/org.apache.click.eclipse/documentation/user-guide/ch01s06.html
new file mode 100644
index 0000000..a55dcfd
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch01s06.html
@@ -0,0 +1,72 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>1.6.&nbsp;Simple Form Example</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch01.html" title="Chapter&nbsp;1.&nbsp;Introduction to Apache Click"><link rel="prev" href="ch01s05.html" title="1.5.&nbsp;Advanced Table Example"><link rel="next" href="ch01s07.html" title="1.7.&nbsp;Advanced Form Example"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">1.6.&nbsp;Simple Form Example</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch01s05.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;1.&nbsp;Introduction to Apache Click</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch01s07.html">Next</a></td></tr></table><hr></div><div class="sect1" title="1.6.&nbsp;Simple Form Example"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="simple-form"></a>1.6.&nbsp;Simple Form Example</h2></div></div></div><p>The <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Form.html" target="_blank">Form</a>
+    and <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Field.html" target="_blank">Field</a>
+    controls are also some of the most commonly used controls in the Click Framework.
+    </p><p>The SimpleForm page below provides a demonstration of using these
+    controls.
+    </p><p>In our example code we have the page's constructor adding a
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/TextField.html" target="_blank">TextField</a>
+    field and a <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Submit.html" target="_blank">Submit</a>
+    button to the form. A page method is also set as a control listener on the
+    form. Also note in this example the page's public <code class="varname">form</code>
+    field is automatically added to its list of controls.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> SimpleForm <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> Form form = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Form();
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> String msg;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// -------------------------------------------------------- Constructor</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> SimpleForm() {
+        form.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> TextField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"name"</span>, true));
+        form.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Submit(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"OK"</span>));
+
+        form.setListener(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">this</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"onSubmit"</span>);
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// ----------------------------------------------------- Event Handlers</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * Handle the form submit event.
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onSubmit() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (form.isValid()) {
+            msg = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Your name is "</span> + form.getFieldValue(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"name"</span>);
+        }
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> true;
+    }
+}</pre><p>Next we have the SimpleForm template <code class="varname">simple-form.htm</code>.
+    The Click application automatically associates the
+    <code class="varname">simple-form.htm</code> template with the
+    <code class="classname">SimpleForm</code> class.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <code class="varname">$headElements</code>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+    <code class="varname">$form</code>
+
+    <span class="command"><strong>#if</strong></span> (<code class="varname">$msg</code>)
+      <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;div</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"msgDiv"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span> <code class="varname">$msg</code> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/div&gt;</span>
+    <span class="command"><strong>#end</strong></span>
+
+    <code class="varname">$jsElements</code>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>When the SimpleForm page is first requested the <code class="varname">$form</code>
+    object will automatically render itself as:
+    </p><div class="figure"><a name="simple-form-image"></a><div class="figure-contents"><div class="mediaobject"><img src="images/introduction/simple-form.png" alt="Simple Form"></div></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;1.4.&nbsp;Simple Form</i></p></div><br class="figure-break"><p>Say the user does not enter their name and presses the OK button to
+    submit the form. The <code class="classname">ClickServlet</code> creates a new
+    SimpleForm page and processes the form control.
+    </p><p>The form control processes its fields and determines that it is
+    invalid. The form then invokes the listener method
+    <code class="methodname">onSubmit()</code>. As the form is not valid this method
+    simply returns true and the form renders the field validation errors.
+    </p><div class="figure"><a name="simple-form-error-image"></a><div class="figure-contents"><div class="mediaobject"><img src="images/introduction/simple-form-error.png" alt="Form after an invalid request"></div></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;1.5.&nbsp;Form after an invalid request</i></p></div><br class="figure-break"><p>Note the form will automatically maintain the entered state during the
+    post and validate cycle.
+    </p><p>Now if the user enters their name and clicks the OK button, the form
+    will be valid and the <code class="methodname">onSubmit()</code> add a
+    <code class="varname">msg</code> to the Pages model. This will be rendered as:
+    </p><div class="figure"><a name="simple-form-success-image"></a><div class="figure-contents"><div class="mediaobject"><img src="images/introduction/simple-form-success.png" alt="Form after a valid request"></div></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;1.6.&nbsp;Form after a valid request</i></p></div><br class="figure-break"></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch01s05.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch01s07.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">1.5.&nbsp;Advanced Table Example&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;1.7.&nbsp;Advanced Form Example</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch01s07.html b/org.apache.click.eclipse/documentation/user-guide/ch01s07.html
new file mode 100644
index 0000000..3231fb0
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch01s07.html
@@ -0,0 +1,127 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>1.7.&nbsp;Advanced Form Example</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch01.html" title="Chapter&nbsp;1.&nbsp;Introduction to Apache Click"><link rel="prev" href="ch01s06.html" title="1.6.&nbsp;Simple Form Example"><link rel="next" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">1.7.&nbsp;Advanced Form Example</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch01s06.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;1.&nbsp;Introduction to Apache Click</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02.html">Next</a></td></tr></table><hr></div><div class="sect1" title="1.7.&nbsp;Advanced Form Example"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="advanced-form"></a>1.7.&nbsp;Advanced Form Example</h2></div></div></div><p>The <code class="classname">AdvancedForm</code> page below provides a more
+    advanced demonstration of using Form, Field and FielsSet controls.
+    </p><p>First we have an <code class="classname">AdvancedForm</code> class which
+    setups up a <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Form.html" target="_blank">Form</a>
+    in its constructor. The form's investment
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Select.html" target="_blank">Select</a>
+    list is populated in the page's <code class="methodname">onInit()</code> method. At
+    this point any page dependencies such as the CustomerService should be
+    available.
+    </p><p>Note in this example the page's public <code class="varname">form</code> field
+    is automatically added to its list of controls. The <code class="varname">msg</code>
+    field is added to the page's model.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> AdvancedForm <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> Form form = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Form();
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> String msg;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> Select investmentSelect = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Select(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"investment"</span>);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// -------------------------------------------------------- Constructor</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> AdvancedForm() {
+        FieldSet fieldSet = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> FieldSet(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Customer"</span>);
+        form.add(fieldSet);
+
+        TextField nameField = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> TextField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"name"</span>, true);
+        nameField.setMinLength(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="lit">5</span>);
+        nameField.setFocus(true);
+        fieldSet.add(nameField);
+
+        fieldSet.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> EmailField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"email"</span>, true));
+
+        fieldSet.add(investmentSelect);
+
+        fieldSet.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> DateField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"dateJoined"</span>, true));
+        fieldSet.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Checkbox(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"active"</span>));
+
+        form.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Submit(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"ok"</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">" OK "</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">this</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"onOkClicked"</span>));
+        form.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Submit(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"cancel"</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">this</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"onCancelClicked"</span>));
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// ----------------------------------------------------- Event Handlers</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see Page#onInit()
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Override</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onInit() {
+        CustomerService customerService = getCustomerService();
+        investmentSelect.add(Option.EMPTY_OPTION);
+        investmentSelect.addAll(customerService.getInvestmentCatetories());
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * Handle the OK button click event.
+     *
+     * @return true
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onOkClicked() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (form.isValid()) {
+            Customer customer = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Customer();
+            form.copyTo(customer);
+
+            getCustomerService().saveCustomer(customer);
+
+            form.clearValues();
+
+            msg = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"A new customer record has been created."</span>;
+        }
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> true;
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * Handle the Cancel button click event.
+     *
+     * @return false
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onCancelClicked() {
+        setRedirect(HomePage.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>);
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+    }
+}</pre><p>Next we have the AdvancedForm template
+    <code class="filename">advanced-form.htm</code>. The Click application automatically
+    associates the <code class="filename">advanced-form.htm</code> template with the
+    <code class="classname">AdvancedForm</code> class.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <code class="varname">$headElements</code>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+    <span class="command"><strong>#if</strong></span> (<code class="varname">$msg</code>)
+      <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;div</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"msgDiv"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span> <code class="varname">$msg</code> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/div&gt;</span>
+    <span class="command"><strong>#end</strong></span>
+
+    <code class="varname">$form</code>
+
+    <code class="varname">$headElements</code>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>When the AdvancedForm page is first requested the
+    <code class="varname">$form</code> object will automatically render itself as:
+    </p><div class="figure"><a name="advanced-form-image"></a><div class="figure-contents"><div class="mediaobject"><img src="images/introduction/advanced-form.png" alt="Advanced Form"></div></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;1.7.&nbsp;Advanced Form</i></p></div><br class="figure-break"><p>In this example when the OK button is clicked the
+    <code class="methodname">onOkClicked()</code> method is invoked. If the form is
+    valid a new customer object is created and the forms field values are copied
+    to the new object using the Form
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Form.html#copyTo(java.lang.Object)" target="_blank">copyTo()</a>
+    method. The customer object is then saved, the form's field values are
+    cleared and an info message is presented to the user.
+    </p><p>If the user clicks on the Cancel button the request is redirected to
+    the applications HomePage.
+    </p><div class="sect2" title="1.7.1.&nbsp;Form Layout"><div class="titlepage"><div><div><h3 class="title"><a name="form-layout"></a>1.7.1.&nbsp;Form Layout</h3></div></div></div><p>In the example above the Form control automatically renders the form
+      and the fields HTML markup. This is a great feature for quickly building
+      screens, and the form control provides a number of layout options. See the
+      Click Examples for an interactive
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://www.avoka.com/click-examples/form/form-properties.htm" target="_blank">Form Properties demo</a>.
+      </p><p>For fine grained page design you can specifically layout form and
+      fields in your page template. See the
+      <a class="link" href="ch03s07.html#template-layout" title="3.7.1.&nbsp;Template layout">Template Layout</a> section and
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Form.html#form-layout" target="_blank">Form</a>
+      Javadoc for more details.
+      </p><p>An alternative to page template design is using a programmatic
+      approach. See <a class="link" href="ch03s07.html#programmatic-layout" title="3.7.2.&nbsp;Programmatic layout">Programmatic Layout</a>
+      for more details.
+      </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch01s06.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch01.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">1.6.&nbsp;Simple Form Example&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;2.&nbsp;Pages</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02.html b/org.apache.click.eclipse/documentation/user-guide/ch02.html
new file mode 100644
index 0000000..4676d1c
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02.html
@@ -0,0 +1,44 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>Chapter&nbsp;2.&nbsp;Pages</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="index.html" title="Apache Click"><link rel="prev" href="ch01s07.html" title="1.7.&nbsp;Advanced Form Example"><link rel="next" href="ch02s02.html" title="2.2.&nbsp;Execution"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;2.&nbsp;Pages</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch01s07.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;2.&nbsp;Pages"><div class="titlepage"><div><div><h2 class="title"><a name="chapter-pages"></a>Chapter&nbsp;2.&nbsp;Pages</h2></div></div></div><div class="toc"><dl><dt><span class="sect1"><a href="ch02.html#classes">2.1. Classes</a></span></dt><dt><span class="sect1"><a href="ch02s02.html">2.2. Execution</a></span></dt><dt><span class="sect1"><a href="ch02s03.html">2.3. Request Parameter Auto Binding</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch02s03.html#customizing-auto-binding">2.3.1. Customizing Auto Binding</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch02s04.html">2.4. Security</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch02s04.html#applications-authentication">2.4.1. Application Authentication</a></span></dt><dt><span class="sect2"><a href="ch02s04.html#container-authentication">2.4.2. Container Authentication</a></span></dt><dt><span class="sect2"><a href="ch02s04.html#container-access-control">2.4.3. Container Access Control</a></span></dt><dt><span class="sect2"><a href="ch02s04.html#logging-out">2.4.4. Logging Out</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch02s05.html">2.5. Page Navigation</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch02s05.html#forward">2.5.1. Forward</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch02s05.html#forward-parameter-passing">2.5.1.1. Forward Parameter Passing</a></span></dt><dt><span class="sect3"><a href="ch02s05.html#page-forwarding">2.5.1.2. Page Forwarding</a></span></dt></dl></dd><dt><span class="sect2"><a href="ch02s05.html#template-path">2.5.2. Template Path</a></span></dt><dt><span class="sect2"><a href="ch02s05.html#redirect">2.5.3. Redirect</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch02s05.html#redirect-parameter-passing">2.5.3.1. Redirect Parameter Passing</a></span></dt><dt><span class="sect3"><a href="ch02s05.html#post-redirect">2.5.3.2. Post Redirect</a></span></dt></dl></dd></dl></dd><dt><span class="sect1"><a href="ch02s06.html">2.6. Page Templating</a></span></dt><dt><span class="sect1"><a href="ch02s07.html">2.7. Direct Rendering</a></span></dt><dt><span class="sect1"><a href="ch02s08.html">2.8. Stateful Pages</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch02s08.html#page-creation">2.8.1. Page Creation</a></span></dt><dt><span class="sect2"><a href="ch02s08.html#page-execution">2.8.2. Page Execution</a></span></dt><dt><span class="sect2"><a href="ch02s08.html#page-destruction">2.8.3. Page Destruction</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch02s09.html">2.9. Error Handling</a></span></dt><dt><span class="sect1"><a href="ch02s10.html">2.10. Page Not Found</a></span></dt><dt><span class="sect1"><a href="ch02s11.html">2.11. Page Message Properties</a></span></dt><dt><span class="sect1"><a href="ch02s12.html">2.12. Page HEAD Elements</a></span></dt></dl></div><p>Pages are the heart of web applications. In Apache Click, Pages encapsulate
+  the processing of HTML requests and the rendering of HTML responses.
+  This chapter discusses Apache Click pages in detail.
+  </p><p>In Click, a logical page is composed of a Java class and a Velocity
+  template, with these components being defined in page elements of the
+  <a class="link" href="ch04s02.html" title="4.2.&nbsp;Application Configuration">click.xml</a>
+  file:
+  </p><div class="literallayout"><p>&lt;page&nbsp;path="<code class="varname">search.htm</code>"&nbsp;classname="<span class="token">com.mycorp.page.Search</span>"/&gt;</p></div><p>The path attribute specifies the location of the page Velocity template,
+  and the classname attribute specifies the page Java class name. If you use
+  the Freemarker template engine instead of Velocity, the setup is the same.
+  </p><p>The template path should have an <code class="varname">.htm</code> extension which
+  is specified in <a class="link" href="ch04.html#servlet-configuration" title="4.1.&nbsp;Servlet Configuration">web.xml</a> to route
+  *.htm requests to the <code class="classname">ClickServlet</code>.
+  </p><p>Please note if you want Click to process templates with a different
+  extension e.g. <code class="varname">.xml</code>, you need to implement the method
+  <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/service/ConfigService.html#isTemplate(java.lang.String)" target="_blank">isTemplate(String path)</a>
+  and specify the extra extensions. The simplest way is to subclass
+  <code class="classname">XmlConfigService</code> and override the default implementation
+  as described <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/service/XmlConfigService.html#isTemplate(java.lang.String)" target="_blank">here</a>.
+  Also remember to map the new extensions in <code class="filename">web.xml</code>.
+  </p><p>If you use JSP pages for rendering, the <code class="varname">.jsp</code> extension
+  must be used. For example:
+  </p><div class="literallayout"><p>&lt;page&nbsp;path="<code class="varname">search.jsp</code>"&nbsp;classname="<span class="token">com.mycorp.page.Search</span>"/&gt;</p></div><p>At runtime Click automatically converts the page path from
+  <code class="varname">.jsp</code> to <code class="varname">.htm</code> and back, so there is no
+  need to map the <code class="varname">.jsp</code> extension in <code class="filename">web.xml</code>.
+  </p><div class="sect1" title="2.1.&nbsp;Classes"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="classes"></a>2.1.&nbsp;Classes</h2></div></div></div><p> All custom Click pages must subclass the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html" target="_blank">Page</a> base class.
+    The Page class and its associated companion classes, Context and Control,
+    are depicted in the figure below.
+    </p><div class="figure"><a name="page-class-diagram"></a><div class="figure-contents"><span class="inlinemediaobject"><img src="images/pages/click-class-diagram.png" alt="Page Class Diagram"></span></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;2.1.&nbsp;Page Class Diagram
+      </i></p></div><br class="figure-break"><p>The Page class provides a
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#model" target="_blank">model</a>
+    attribute which is used to hold all the objects that are rendered in the
+    page's Velocity template. The model may also contain
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html" target="_blank">Control</a>
+    objects, which provide user interface controls on the Page.
+    </p><p>Pages also have an associated
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Context.html" target="_blank">Context</a>
+    object which references all the javax.servlet objects associated with the
+    request. When programming in Click you use the Context object to access
+    HttpServletRequest attributes, parameters and the HttpSession object.
+    </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch01s07.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">1.7.&nbsp;Advanced Form Example&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;2.2.&nbsp;Execution</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02s02.html b/org.apache.click.eclipse/documentation/user-guide/ch02s02.html
new file mode 100644
index 0000000..1c74245
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02s02.html
@@ -0,0 +1,94 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>2.2.&nbsp;Execution</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="prev" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="next" href="ch02s03.html" title="2.3.&nbsp;Request Parameter Auto Binding"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2.2.&nbsp;Execution</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;Pages</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="2.2.&nbsp;Execution"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="execution"></a>2.2.&nbsp;Execution</h2></div></div></div><p>The Page class provide a number of empty handler methods which
+    subclasses can override to provide functionality:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#onSecurityCheck()" target="_blank">onSecurityCheck()</a>
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#onInit()" target="_blank">onInit()</a>
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#onGet()" target="_blank">onGet()</a>
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#onPost()" target="_blank">onPost()</a>
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#onRender()" target="_blank">onRender()</a>
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#onDestroy()" target="_blank">onDestroy()</a>
+        </p></li></ul></div><p>The ClickServlet relies on instantiating Pages using a public no
+    arguments constructor, so when you create Page subclasses you must ensure
+    you don't add an incompatible constructor. The GET request execution sequence
+    for Pages is summarized below in the Figure 2.
+    </p><div class="figure"><a name="get-sequence-diagram"></a><div class="figure-contents"><span class="inlinemediaobject"><img src="images/pages/get-sequence-diagram.png" alt="GET Request Sequence Diagram"></span></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;2.2.&nbsp;GET Request Sequence Diagram
+      </i></p></div><br class="figure-break"><p>Stepping through this GET request sequence, a new Page instance is
+    created and the attributes for the Page are set (context, format, headers,
+    path). Next, request parameter values are bound to any matching public
+    Page fields.
+    </p><p>Then the <code class="methodname">onSecurityCheck()</code> handler is executed.
+    This method can be used to ensure the user is authorized to access the page,
+    and if necessary abort any further processing.
+    </p><p>The next method invoked is <code class="methodname">onInit()</code>, this is
+    where you place any post constructor initialization code.
+    <code class="methodname">onInit()</code> is the ideal place to create controls such
+    as Forms, Fields and Tables. As illustrated by the diagram, after a Page's
+    <code class="methodname">onInit()</code> is called, each Control, available at that
+    stage, will have their <code class="methodname">onInit()</code> method called.
+    </p><p>
+    The next step is the processing of the Page's
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#controls" target="_blank">controls</a>.
+    The ClickServlet gets the list of Controls from the page and then iterates
+    through the list calling <code class="methodname">onProcess()</code>. If any of the
+    Control's <code class="methodname">onProcess()</code> methods return false,
+    processing of subsequent controls and the Page's <code class="methodname">onGet()</code>
+    method is aborted.
+    </p><p>If everything is executing normally the Page's
+    <code class="methodname">onGet()</code> method is now called.
+    </p><p>The next step is rendering the page template to generate the displayed
+    HTML. The ClickServlet gets the model (<code class="classname">Map</code>) from the
+    Page then adds the following objects to the model:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>any public Page fields using the fields name</p></li><li class="listitem"><p>context &nbsp;-&nbsp; the Servlet context path, e.g. /mycorp</p></li><li class="listitem"><p>format &nbsp;-&nbsp; the
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/Format.html" target="_blank">Format</a>
+        object for formatting the display of objects.
+        </p></li><li class="listitem"><p>headElements &nbsp;-&nbsp; the HEAD <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/element/Element.html" target="_blank">elements</a>,
+        excluding JavaScript, to include in the page header. Please see
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/PageImports.html" target="_blank">PageImports</a>
+        for more details.
+        </p></li><li class="listitem"><p>jsElements &nbsp;-&nbsp; the JavaScript imports and script blocks to
+        include in the pages footer. Please see
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/PageImports.html" target="_blank">PageImports</a>
+        for more details.
+        </p></li><li class="listitem"><p>messages &nbsp;-&nbsp; the
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/MessagesMap.html" target="_blank">MessagesMap</a>
+        adaptor for the Page
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#getMessage(java.lang.String)" target="_blank">getMessage()</a>
+        method
+        </p></li><li class="listitem"><p>path &nbsp;-&nbsp; the
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#path" target="_blank">path</a> of
+        the page template to render
+        </p></li><li class="listitem"><p>request &nbsp;-&nbsp; the pages
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpServletRequest.html" target="_blank">HttpServletRequest</a>
+        object
+        </p></li><li class="listitem"><p>response &nbsp;-&nbsp; the pages
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpServletResponse.html" target="_blank">HttpServletResponse</a>
+        object
+        </p></li><li class="listitem"><p>session &nbsp;-&nbsp; the
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/SessionMap.html" target="_blank">SessionMap</a>
+        adaptor for the users
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpSession.html" target="_blank">HttpSession</a>
+        </p></li></ul></div><p>It then merges the template with the page model and writes out results
+    to the HttpServletResponse. When the model is being merged with the template,
+    any Controls in the model may be rendered using their
+    <code class="methodname">toString()</code> method.
+    </p><p>The final step in this sequence is invoking each control's
+    <code class="methodname">onDestroy()</code> method and lastly invoke the Page's
+    <code class="methodname">onDestroy()</code> method. This method can be used to
+    clean up resource associated with the Control or Page before it is garbage
+    collected. The <code class="methodname">onDestroy()</code> method is guaranteed to
+    be called even if an exception occurs in the previous steps.
+    </p><p>The execution sequence for POST requests is almost identical, except
+    the <code class="methodname">onPost()</code> method is invoked instead on
+    <code class="methodname">onGet()</code>. See the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../../images/post-sequence-diagram.png" target="_blank">POST Request Sequence Diagram</a>.
+    </p><p>Another view on the execution flow of Pages is illustrated in the
+    Activity diagram below.
+    </p><div class="figure"><a name="activity-diagram"></a><div class="figure-contents"><span class="inlinemediaobject"><img src="images/pages/activity-diagram-small.png" alt="Page Execution Activity Diagram"></span></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;2.3.&nbsp;Page Execution Activity Diagram
+      </i></p></div><br class="figure-break"></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;2.&nbsp;Pages&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;2.3.&nbsp;Request Parameter Auto Binding</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02s03.html b/org.apache.click.eclipse/documentation/user-guide/ch02s03.html
new file mode 100644
index 0000000..24d640f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02s03.html
@@ -0,0 +1,91 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>2.3.&nbsp;Request Parameter Auto Binding</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="prev" href="ch02s02.html" title="2.2.&nbsp;Execution"><link rel="next" href="ch02s04.html" title="2.4.&nbsp;Security"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2.3.&nbsp;Request Parameter Auto Binding</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;Pages</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s04.html">Next</a></td></tr></table><hr></div><div class="sect1" title="2.3.&nbsp;Request Parameter Auto Binding"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="request-param-auto-binding"></a>2.3.&nbsp;Request Parameter Auto Binding</h2></div></div></div><p>Click will automatically bind any request parameter values to public
+    Page fields with the same name. You can also use the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/Bindable.html" target="_blank">Bindable</a>
+    annotation to bind private and protected Page fields. When binding these
+    values Click will also attempt to convert them to the correct type.
+    </p><p>The best way to understand this is to walk through an example. Our
+    application recieves a GET request:
+    </p><div class="literallayout"><p>http://localhost:8080/mycorp/customer-details.htm?<code class="varname">customerId</code>=<span class="symbol">7203</span></p></div><p>This request is automatically handled by our
+    <code class="classname">CustomerDetails</code> page:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">package</span> com.mycorp.page;
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> CustomerDetails <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> Integer <code class="varname">customerId</code>;
+}</pre><p>After the CustomerDetails page has been created the
+    "<code class="varname">customerId</code>" request parameter value "<span class="symbol">7023</span>"
+    will be converted into an Integer and assigned to the public page field
+    <code class="varname">customerId</code>.
+    </p><p>Another feature of Click is that any public Page fields are
+    automatically added to the page's model before it is rendered. This will
+    make these values available in the page template for display. In our example
+    the public <code class="varname">customerId</code> field will be added to the Page
+    model and will be available for rendering in the page template.
+    </p><p>Our customer-details.htm page template contains:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+  Customer ID: <span class="symbol">$</span><code class="varname">customerId</code>
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>After processing the request our page would be rendered as:
+    </p><div class="literallayout"><p>Customer&nbsp;ID:&nbsp;7203</p></div><div class="sect2" title="2.3.1.&nbsp;Customizing Auto Binding"><div class="titlepage"><div><div><h3 class="title"><a name="customizing-auto-binding"></a>2.3.1.&nbsp;Customizing Auto Binding</h3></div></div></div><p>Auto binding supports the conversion of request string parameters
+      into the Java classes: Integer, Double, Boolean, Byte, Character, Short,
+      Long, Float, BigInteger, BigDecimal, String and the various Date classes.
+      </p><p>By default type conversion is performed by the
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/RequestTypeConverter.html" target="_blank">RequestTypeConverter</a>
+      class which is used by the ClickServlet method
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/ClickServlet.html#getTypeConverter()" target="_blank">getTypeConverter()</a>.
+      </p><p>If you need to add support for additional types, you would write your
+      own type converter class and specify it as a ClickServlet init parameter.
+      </p><p>For example if you wanted to automatically load a
+      <code class="classname">Customer</code> object from the database when a customer
+      id request parameter is specified, you could write your own type converter:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> CustomTypeConverter <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> RequestTypeConverter {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> CustomerService customerService = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> CustomerService();
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see RequestTypeConverter#convertValue(Object, Class)
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> Object convertValue(Object value, Class toType) {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (toType == Customer.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>) {
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> customerService.getCustomerForId(value);
+
+        } <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">else</span> {
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">super</span>.convertValue(value, toType);
+        }
+    }
+}</pre><p>This type converter would handle the following request:
+      </p><div class="literallayout"><p>http://localhost:8080/mycorp/customer-details.htm?<code class="varname">customer</code>=<span class="symbol">7203</span></p></div><p>This request will load the <code class="varname">customer</code> object from
+      the database using "<span class="symbol">7203</span>" as the customer id value. The
+      ClickServlet would then assign this <code class="varname">customer</code> object to
+      the matching page field:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">package</span> com.mycorp.page;
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> CustomerDetails <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pun">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> Customer <code class="varname">customer</code>;
+
+}</pre><p>To make your custom type converter available you will need to
+      add an init parameter to ClickServlet in <code class="filename">web.xml</code>. For example:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;web-app&gt;</span>
+  ...
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-name&gt;</span>ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-name&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-class&gt;</span>org.apache.click.ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-class&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;init-param&gt;</span>
+       <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;param-name&gt;</span>type-converter-class<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/param-name&gt;</span>
+       <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;param-value&gt;</span>com.mycorp.util.CustomTypeConverter<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/param-value&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/init-param&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;load-on-startup&gt;</span>0<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/load-on-startup&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-mapping&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-name&gt;</span>ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-name&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;url-pattern&gt;</span>*.htm<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/url-pattern&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-mapping&gt;</span>
+  ...
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/web-app&gt;</span></pre></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s04.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">2.2.&nbsp;Execution&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;2.4.&nbsp;Security</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02s04.html b/org.apache.click.eclipse/documentation/user-guide/ch02s04.html
new file mode 100644
index 0000000..717a808
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02s04.html
@@ -0,0 +1,80 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>2.4.&nbsp;Security</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="prev" href="ch02s03.html" title="2.3.&nbsp;Request Parameter Auto Binding"><link rel="next" href="ch02s05.html" title="2.5.&nbsp;Page Navigation"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2.4.&nbsp;Security</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s03.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;Pages</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s05.html">Next</a></td></tr></table><hr></div><div class="sect1" title="2.4.&nbsp;Security"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="page-security"></a>2.4.&nbsp;Security</h2></div></div></div><p>Pages provide an
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#onSecurityCheck()" target="_blank">onSecurityCheck</a>
+    event handler which application pages can override to implement a
+    programmatic security model.
+    </p><p>Please note you generally don't need to use this capability, and where
+    possible you should use the declarative JEE security model. See the Best
+    Practices <a class="link" href="ch05.html#security" title="5.1.&nbsp;Security">Security</a> topic for more details.
+    </p><div class="sect2" title="2.4.1.&nbsp;Application Authentication"><div class="titlepage"><div><div><h3 class="title"><a name="applications-authentication"></a>2.4.1.&nbsp;Application Authentication</h3></div></div></div><p>Applications can use the <code class="methodname">onSecurityCheck()</code>
+      method to implement their own security model. The example class below
+      provides a base Secure page class which other pages can extend to ensure
+      the user is logged in. In this example the login page creates a session
+      when a user successfully authenticates. This Secure page then checks to
+      make sure the user has a session, otherwise the request is redirected to
+      the login page.
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> Secure <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see Page#onSecurityCheck()
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onSecurityCheck() {
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (getContext().hasSession()) {
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> true;
+
+        } <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">else</span> {
+            setRedirect(LoginPage.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>);
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+        }
+    }
+}</pre></div><div class="sect2" title="2.4.2.&nbsp;Container Authentication"><div class="titlepage"><div><div><h3 class="title"><a name="container-authentication"></a>2.4.2.&nbsp;Container Authentication</h3></div></div></div><p>Alternatively you can also use the security services provided by
+      the JEE Servlet Container. For instance to ensure users have been
+      authenticated by the Serlvet Container you could use a Secure page of:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> Secure <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see Page#onSecurityCheck()
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onSecurityCheck() {
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (getContext().getRequest().<a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpServletRequest.html#getRemoteUser()" target="_blank"><code class="varname">getRemoteUser</code></a>() != null) {
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> true;
+
+        } <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">else</span> {
+            setRedirect(LoginPage.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>);
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+        }
+    }
+}</pre></div><div class="sect2" title="2.4.3.&nbsp;Container Access Control"><div class="titlepage"><div><div><h3 class="title"><a name="container-access-control"></a>2.4.3.&nbsp;Container Access Control</h3></div></div></div><p>The Servlet Container also provides facilities to enforce role
+      based access control (authorization). The example below is a base page
+      to ensure only users in the "admin" role can access the page, otherwise
+      users are redirected to the login page. Application Admin pages would
+      extend this secure page to provide their functionality.
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> AdminPage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see Page#onSecurityCheck()
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onSecurityCheck() {
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (getContext().getRequest().<a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpServletRequest.html#isUserInRole(java.lang.String)" target="_blank"><code class="varname">isUserInRole</code></a>(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"admin"</span>)) {
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> true;
+
+        } <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">else</span> {
+            setRedirect(LoginPage.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>);
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+        }
+    }
+}</pre></div><div class="sect2" title="2.4.4.&nbsp;Logging Out"><div class="titlepage"><div><div><h3 class="title"><a name="logging-out"></a>2.4.4.&nbsp;Logging Out</h3></div></div></div><p>To logout using the application or container based security models
+      you would simply invalidate the session.
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> Logout <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see Page#onInit()
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onInit() {
+        getContext().getSession().<a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpSession.html#invalidate()" target="_blank"><code class="varname">invalidate</code></a>();
+    }
+}</pre></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s03.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s05.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">2.3.&nbsp;Request Parameter Auto Binding&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;2.5.&nbsp;Page Navigation</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02s05.html b/org.apache.click.eclipse/documentation/user-guide/ch02s05.html
new file mode 100644
index 0000000..d3681fc
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02s05.html
@@ -0,0 +1,194 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>2.5.&nbsp;Page Navigation</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="prev" href="ch02s04.html" title="2.4.&nbsp;Security"><link rel="next" href="ch02s06.html" title="2.6.&nbsp;Page Templating"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2.5.&nbsp;Page Navigation</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s04.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;Pages</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s06.html">Next</a></td></tr></table><hr></div><div class="sect1" title="2.5.&nbsp;Page Navigation"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="page-navigation"></a>2.5.&nbsp;Page Navigation</h2></div></div></div><p> Navigation between pages is achieved by using forwards, redirects
+    and by setting the page template path.
+    </p><div class="sect2" title="2.5.1.&nbsp;Forward"><div class="titlepage"><div><div><h3 class="title"><a name="forward"></a>2.5.1.&nbsp;Forward</h3></div></div></div><p> To forward to another page using the servlet
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/RequestDispatcher.html" target="_blank">RequestDispatcher</a>,
+      set the Page's forward property. For example to forward to a page with a
+      path <code class="varname">index.htm</code>:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+ * @see Page#onPost()
+ */</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onPost() {
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Process form post</span>
+    ..
+
+    setForward(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"index.htm"</span>);
+}</pre><p>This will invoke a new Page class instance mapped to the path
+      <code class="varname">index.htm</code>.
+      </p><p><span class="bold"><strong>Please note</strong></span> when a request is
+      forwarded to another Page, the controls on the second page will not be
+      processed. This prevents confusion and bugs, like a form on the second page
+      trying to process a POST request from the first page.
+      </p><div class="sect3" title="2.5.1.1.&nbsp;Forward Parameter Passing"><div class="titlepage"><div><div><h4 class="title"><a name="forward-parameter-passing"></a>2.5.1.1.&nbsp;Forward Parameter Passing</h4></div></div></div><p>When you forward to another page the request parameters are
+        maintained. This is a handy way of passing through state information
+        with the request. For example you could add a customer object as a
+        request parameter which is displayed in the template of the forwarded
+        page.
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onViewClick() {
+    Long id = viewLink.getValueLong();
+    Customer customer = CustomerDAO.findByPK(id);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Set the customer object as a request parameter</span>
+    getContext().setRequestAttribute(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"customer"</span>, customer);
+    setForward(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"view-customer.htm"</span>);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+}</pre><p>The snippet above forwards to the page template
+        <code class="varname">view-customer.htm</code>:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+ <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;title&gt;</span>Customer Details<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/title&gt;</span>
+ <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+ <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;h1&gt;</span>Customer Details<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/h1&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pre&gt;</span>
+     Full Name: <code class="varname">$customer.fullName</code>
+     Email:     <code class="varname">$customer.email</code>
+     Telephone: <code class="varname">$customer.telephone</code>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/pre&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>Request attributes are automatically added to the Velocity Context
+    object so are available in the page template.
+        </p></div><div class="sect3" title="2.5.1.2.&nbsp;Page Forwarding"><div class="titlepage"><div><div><h4 class="title"><a name="page-forwarding"></a>2.5.1.2.&nbsp;Page Forwarding</h4></div></div></div><p>Page forwarding is another way of passing information between
+        pages. In this case you create the page to be forwarded to using the
+        Context <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Context.html#createPage(java.lang.String)" target="_blank">createPage(String)</a>
+        method and then set properties directly on the Page. Finally set this
+        page as the page to forward the request to. For example:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onEditClick() {
+    Long id = viewLink.getValueLong();
+    Customer customer = CustomerDAO.findByPK(id);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create a new EditPage instance based on the specified path</span>
+    EditPage editPage = (EditPage) getContext().createPage(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/edit-customer.htm"</span>);
+    editPage.setCustomer(customer);
+    setForward(editPage);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+}</pre><p>When creating a page with the <code class="methodname">createPage()</code>
+        method, ensure you prefix the page path with the <code class="varname">"/"</code>
+        character.
+        </p><p>You can also specify the target page using its class as long as
+        the Page has a unique path. Using this technique the above code becomes:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onEditClick() {
+    Long id = viewLink.getValueLong();
+    Customer customer = CustomerDAO.findByPK(id);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create a new EditPage instance based on its class</span>
+    EditPage editPage = (EditPage) getContext().createPage(EditPage.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>);
+    editPage.setCustomer(customer);
+    setForward(editPage);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+}</pre><p>This Page forwarding technique is best practice as it provides you
+        with compile time safety and alleviates you from having to specify page
+        paths in your code. Please always use the Context
+        <code class="methodname">createPage()</code> methods to allow Click to inject
+        Page dependencies.
+        </p><p>Although uncommon it is possible to map more than one path to the
+        same class. In these cases invoking Context
+        <code class="methodname">createPage(Class)</code> will throw an exception, because
+        Click will not be able to determine which path to use for the Page.
+        </p></div></div><div class="sect2" title="2.5.2.&nbsp;Template Path"><div class="titlepage"><div><div><h3 class="title"><a name="template-path"></a>2.5.2.&nbsp;Template Path</h3></div></div></div><p>An alternative method of forwarding to a new page is to simply set
+      the current Page's path to the new page template to render. With this
+      approach the page template being rendered must have everything it needs
+      without having its associated Page object created. Our modified example
+      would be:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onViewClick() {
+    Long id = viewLink.getValueLong();
+    Customer customer = CustomerDAO.findByPK(id);
+
+    addModel(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"customer"</span>, customer);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Set the Page's path to a new value</span>
+    setPath(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"view-customer.htm"</span>);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+}</pre><p>Note how the <code class="varname">customer</code> object is passed through to
+      the template in the Page model. This approach of using the Page model is
+      not available when you forward to another Page, as the first Page object is
+      "<a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#onDestroy()" target="_blank">destroyed</a>"
+      before the second Page object is created and any model values would be lost.
+      </p></div><div class="sect2" title="2.5.3.&nbsp;Redirect"><div class="titlepage"><div><div><h3 class="title"><a name="redirect"></a>2.5.3.&nbsp;Redirect</h3></div></div></div><p>Redirects are another very useful way to navigate between pages.
+      See HttpServletResponse.
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpServletResponse.html#sendRedirect(java.lang.String)" target="_blank">sendRedirect</a>
+      (location) for details.
+      </p><p>The great thing about redirects are that they provide a clean URL in
+      the users browser which matches the page that they are viewing. This is
+      important for when users want to bookmark a page. The downside of
+      redirects are that they involve a communications round trip with the users
+      browser which requests the new page. Not only does this take time, it also
+      means that all the page and request information is lost.
+      </p><p>An example of a redirect to a <code class="varname">logout.htm</code> page is
+      provided below:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onLogoutClick() {
+    setRedirect(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/logout.htm"</span>);
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+}</pre><p>If the redirect location begins with a <span class="symbol">"/"</span> character
+      the redirect location will be prefixed with the web applications context
+      path. For example if an application is deployed to the context
+      <code class="varname">"mycorp"</code> calling
+      <code class="methodname">setRedirect(<code class="varname">"/customer/details.htm"</code>)</code>
+      will redirect the request to: <code class="varname">"/mycorp/customer/details.htm"</code>.
+      </p><p>You can also obtain the redirect path via the target Page's class.
+      For example:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onLogoutClick() {
+    String path = getContext().getPagePath(Logout.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>);
+    setRedirect(path);
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+}</pre><p>Note when using this redirect method, the target Page class must have
+      a unique path.
+      </p><p>A short hand way of redirecting is to simply specify the target Page
+      class in the redirect method. For example:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onLogoutClick() {
+    setRedirect(Logout.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>);
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+}</pre><div class="sect3" title="2.5.3.1.&nbsp;Redirect Parameter Passing"><div class="titlepage"><div><div><h4 class="title"><a name="redirect-parameter-passing"></a>2.5.3.1.&nbsp;Redirect Parameter Passing</h4></div></div></div><p>You can pass information between redirected pages using URL
+        request parameters. The ClickServlet will encode the URL for you using
+        HttpServletResponse.<a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpServletResponse.html#encodeRedirectURL(java.lang.String)" target="_blank">encodeRedirectURL</a>
+        (url).
+        </p><p>In the example below a user will click on an OK button to confirm
+        a payment. The <code class="methodname">onOkClick()</code> button handler
+        processes the payment, gets the payment transaction id, and then
+        redirects to the <code class="varname">trans-complete.htm</code> page with the
+        transaction id encoded in the URL.
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> Payment <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+    ..
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onOkClick() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (form.isValid()) {
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Process payment</span>
+            ..
+
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Get transaction id</span>
+            Long transId = OrderDAO.purchase(order);
+
+            setRedirect(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"trans-complete.htm?transId="</span> + transId);
+
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+        }
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> true;
+    }
+}</pre><p>The Page class for the trans-complete.htm page can then get the
+        transaction id through the request parameter <code class="varname">"transId"</code>:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> TransComplete <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see Page#onInit()
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onInit() {
+        String transId = getContext().getRequest().getParameter(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"transId"</span>);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (transId != null) {
+
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Get order details</span>
+            Order order = OrderDAO.findOrderByPK(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Long(transId));
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (order != null) {
+                addModel(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"order"</span>, order);
+            }
+        }
+    }
+}</pre></div><div class="sect3" title="2.5.3.2.&nbsp;Post Redirect"><div class="titlepage"><div><div><h4 class="title"><a name="post-redirect"></a>2.5.3.2.&nbsp;Post Redirect</h4></div></div></div><p>The parameter passing example above is also an example of a Post
+        Redirect. The Post Redirect technique is a very useful method of
+        preventing users from submitting a form twice by hitting the refresh
+        button.
+        </p></div></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s04.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s06.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">2.4.&nbsp;Security&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;2.6.&nbsp;Page Templating</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02s06.html b/org.apache.click.eclipse/documentation/user-guide/ch02s06.html
new file mode 100644
index 0000000..4dc2dca
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02s06.html
@@ -0,0 +1,66 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>2.6.&nbsp;Page Templating</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="prev" href="ch02s05.html" title="2.5.&nbsp;Page Navigation"><link rel="next" href="ch02s07.html" title="2.7.&nbsp;Direct Rendering"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2.6.&nbsp;Page Templating</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s05.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;Pages</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s07.html">Next</a></td></tr></table><hr></div><div class="sect1" title="2.6.&nbsp;Page Templating"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="page-templating"></a>2.6.&nbsp;Page Templating</h2></div></div></div><p>Click supports page templating (a.k.a. <span class="emphasis"><em>Tiles</em></span> in
+    Struts) enabling you to create a standardized look and feel for your web
+    application and greatly reducing the amount of HTML you need to maintain.
+    </p><p>To implement templating define a border template base Page which
+    content Pages should extend. The template base Page class overrides the Page
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#getTemplate()" target="_blank">getTemplate()</a>
+    method, returning the path of the border template to render. For example:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> BorderedPage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see Page#getTemplate()
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> String getTemplate() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/border.htm"</span>;
+    }
+}</pre><p>The BorderedPage template <code class="varname">border.htm</code>:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;title&gt;</span><code class="varname">$title</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/title&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;link</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">rel</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"stylesheet"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/css"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">href</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"style.css"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">title</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Style"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;h2</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">class</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"title"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span><code class="varname">$title</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/h2&gt;</span>
+
+    <span class="command"><strong>#parse</strong></span>(<code class="varname">$path</code>)
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span>
+    </pre><p>Other pages insert their content into this template using the Velocity
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../velocity/vtl-reference-guide.html#parse" target="_blank">#parse</a>
+    directive, passing it their contents pages
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#path" target="_blank">path</a>. The
+    <code class="varname">$path</code> value is automatically added to the VelocityContext
+    by the ClickServlet.
+    </p><p>An example bordered Home page is provided below:
+    </p><div class="literallayout"><p>&lt;page&nbsp;path="<code class="varname">home.htm</code>"&nbsp;classname="<span class="token">Home</span>"/&gt;</p></div><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> Home <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> BorderedPage {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> String title = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Home"</span>;
+
+}</pre><p>The Home page's content <code class="varname">home.htm</code>:
+    </p><div class="literallayout"><p>&lt;b&gt;Welcome&lt;/b&gt;&nbsp;to&nbsp;Home&nbsp;page&nbsp;your&nbsp;starting&nbsp;point&nbsp;for&nbsp;the&nbsp;application.</p></div><p>When a request is made for the Home page (home.htm) Velocity will
+    merge the <code class="varname">border.htm</code> page and <code class="varname">home.htm</code>
+    page together returning:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;title&gt;</span>Home<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/title&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;link</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">rel</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"stylesheet"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/css"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">href</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"style.css"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">title</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Style"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;h2</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">class</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"title"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>Home<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/h2&gt;</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;b&gt;</span>Welcome<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/b&gt;</span> to Home page your application starting point.
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>Which may be rendered as:
+    </p><div class="figure"><a name="home-page-screenshot"></a><div class="figure-contents"><div class="mediaobject"><img src="images/pages/home-page-screenshot.png" alt="Home Page"></div></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;2.4.&nbsp;Home Page</i></p></div><br class="figure-break"><p>Note how the Home page class defines a <code class="varname">title</code> model
+    value which is referenced in the <code class="varname">border.htm</code> template as
+    <code class="varname">$title</code>. Each bordered page can define their own title
+    which is rendered in this template.
+    </p><p>Templating with JSP pages is also supported using the same pattern.
+    Please see the Click Examples application for a demonstration.
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s05.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s07.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">2.5.&nbsp;Page Navigation&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;2.7.&nbsp;Direct Rendering</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02s07.html b/org.apache.click.eclipse/documentation/user-guide/ch02s07.html
new file mode 100644
index 0000000..10e2a8f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02s07.html
@@ -0,0 +1,47 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>2.7.&nbsp;Direct Rendering</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="prev" href="ch02s06.html" title="2.6.&nbsp;Page Templating"><link rel="next" href="ch02s08.html" title="2.8.&nbsp;Stateful Pages"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2.7.&nbsp;Direct Rendering</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s06.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;Pages</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s08.html">Next</a></td></tr></table><hr></div><div class="sect1" title="2.7.&nbsp;Direct Rendering"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="page-direct-rendering"></a>2.7.&nbsp;Direct Rendering</h2></div></div></div><p>Pages support a direct rendering mode where you can render directly
+    to the servlet response and bypass the page template rendering. This is
+    useful for scenarios where you want to render non HTML content to the
+    response, such as a PDF or Excel document. To do this:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p> get the servlet response object</p></li><li class="listitem"><p> set the content type on the response</p></li><li class="listitem"><p> get the response output stream</p></li><li class="listitem"><p> write to the output stream</p></li><li class="listitem"><p> close the output stream</p></li><li class="listitem"><p> set the page path to null to inform the ClickServlet that
+        rendering has been completed</p></li></ul></div><p>A direct rendering example is provided below.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+ * Render the Java source file as "text/plain".
+ *
+ * @see Page#onGet()
+ */</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onGet() {
+    String filename = ..
+
+    HttpServletResponse response = getContext().getResponse();
+
+    response.setContentType(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"text/plain"</span>);
+    response.setHeader(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Pragma"</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"no-cache"</span>);
+
+    ServletContext context = getContext().getServletContext();
+
+    InputStream inputStream = null;
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">try</span> {
+        inputStream = context.getResourceAsStream(filename);
+
+        PrintWriter writer = response.getWriter();
+
+        BufferedReader reader = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> BufferedReader(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> InputStreamReader(inputStream));
+
+        String line = reader.readLine();
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">while</span> (line != null) {
+            writer.println(line);
+            line = reader.readLine();
+        }
+
+        setPath(null);
+
+    } <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">catch</span> (IOException ioe) {
+        ioe.printStackTrace();
+
+    } <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">finally</span> {
+        ClickUtils.close(inputStream);
+    }
+}</pre></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s06.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s08.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">2.6.&nbsp;Page Templating&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;2.8.&nbsp;Stateful Pages</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02s08.html b/org.apache.click.eclipse/documentation/user-guide/ch02s08.html
new file mode 100644
index 0000000..1d59748
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02s08.html
@@ -0,0 +1,66 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>2.8.&nbsp;Stateful Pages</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="prev" href="ch02s07.html" title="2.7.&nbsp;Direct Rendering"><link rel="next" href="ch02s09.html" title="2.9.&nbsp;Error Handling"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2.8.&nbsp;Stateful Pages</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s07.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;Pages</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s09.html">Next</a></td></tr></table><hr></div><div class="sect1" title="2.8.&nbsp;Stateful Pages"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="stateful-pages"></a>2.8.&nbsp;Stateful Pages</h2></div></div></div><p>Click supports stateful pages where the state of the page is saved
+    between the users requests. Stateful pages are useful in a number of
+    scenarios including:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Search page and edit page interactions. In this scenario you
+        navigage from a stateful search page which may have filter criteria
+        applied to an object edit page. Once object update has been completed
+        on the edit page, the user is redirected to the search page and the
+        stateful filter criteria still applies.
+        </p></li><li class="listitem"><p>Complex pages with multiple forms and or tables which need to
+        maintain their state between interactions.
+        </p></li></ul></div><p>To make a page stateful you simply need to set the page
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#stateful" target="_blank">stateful</a>
+    property to true, have the page implement the <code class="classname">Serializable</code>
+    interface and set the <code class="literal">serialVersionUID</code> indicator.
+    For example:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">package</span> com.mycorp.page;
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">import</span> java.io.Serializable;
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">import</span> org.apache.click.Page;
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> SearchPage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">implements</span> Serializable {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">static</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">final</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">long</span> serialVersionUID = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="lit">1L</span>;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> SearchPage() {
+        setStateful(true);
+        ..
+    }
+}</pre><p>Stateful page instances are stored in the user's
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpSession.html" target="_blank">HttpSession</a>
+    using the pages class name as the key. In the example above the page would
+    be stored in the users session using the class name:
+    <code class="classname">com.mycorp.page.SearchPage</code>
+    </p><div class="sect2" title="2.8.1.&nbsp;Page Creation"><div class="titlepage"><div><div><h3 class="title"><a name="page-creation"></a>2.8.1.&nbsp;Page Creation</h3></div></div></div><p>With stateful pages they are only created once, after which they
+      are retrieved from the session. However page event handlers are invoked
+      for each request, including the <code class="methodname">onInit()</code> method.
+      </p><p>When you are creating stateful pages you typically place all your
+      control creation code in the Pages constructor so it is invoked only once.
+      It is important not to place control creation code in the
+      <code class="methodname">onInit()</code> method which will be invoked with each
+      request.
+      </p><p>If you have dynamic control creation code you would typically place
+      this in the <code class="methodname">onInit()</code> method, but you will need to
+      take care that controls and or models are not already present in the page.
+      </p></div><div class="sect2" title="2.8.2.&nbsp;Page Execution"><div class="titlepage"><div><div><h3 class="title"><a name="page-execution"></a>2.8.2.&nbsp;Page Execution</h3></div></div></div><p>The default Click page execution model is thread safe as a new
+      Page instance is created for each request and thread. With stateful
+      pages a user will have a single page instance which is reused in multiple
+      requests and threads. To ensure page execution is thread safe, users page
+      instances are synchronized so only one request thread can execute a page
+      instance at any one time.
+      </p></div><div class="sect2" title="2.8.3.&nbsp;Page Destruction"><div class="titlepage"><div><div><h3 class="title"><a name="page-destruction"></a>2.8.3.&nbsp;Page Destruction</h3></div></div></div><p>After normal page instances have been executed, they are
+      de-referenced and garbage collected by the JVM. However with stateful
+      pages they are stored in the users <code class="classname">HttpSession</code> so
+      care needs to be take not to store too many objects in stateful page
+      instances which may cause memory and performance issues.
+      </p><p>When pages have completed their execution, all the Page's controls
+      <code class="methodname">onDestroy()</code> methods are invoked, and then the
+      Page's <code class="methodname">onDestroy()</code> method is invoked. This is
+      your opportunity to de-reference any large sets or graphs. For example the
+      Table control by default de-references its rowList in its
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Table.html#onDestroy()" target="_blank">onDestory()</a>
+      method.
+      </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s07.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s09.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">2.7.&nbsp;Direct Rendering&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;2.9.&nbsp;Error Handling</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02s09.html b/org.apache.click.eclipse/documentation/user-guide/ch02s09.html
new file mode 100644
index 0000000..657c2b4
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02s09.html
@@ -0,0 +1,32 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>2.9.&nbsp;Error Handling</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="prev" href="ch02s08.html" title="2.8.&nbsp;Stateful Pages"><link rel="next" href="ch02s10.html" title="2.10.&nbsp;Page Not Found"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2.9.&nbsp;Error Handling</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s08.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;Pages</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s10.html">Next</a></td></tr></table><hr></div><div class="sect1" title="2.9.&nbsp;Error Handling"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="page-error-handling"></a>2.9.&nbsp;Error Handling</h2></div></div></div><p>If an Exception occurs processing a Page object or rendering a
+    template the error is delegated to the registered handler. The default
+    Click error handler is the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/ErrorPage.html" target="_blank">ErrorPage</a>,
+    which is automatically configured as:
+    </p><div class="literallayout"><p>&lt;page&nbsp;path="<code class="varname">click/error.htm</code>"&nbsp;classname="<span class="symbol">org.apache.click.util.ErrorPage</span>"/&gt;</p></div><p>To register an alternative error handler you must subclass ErrorPage
+    and define your page using the path <code class="varname">"click/error.htm"</code>.
+    For example:
+    </p><div class="literallayout"><p>&lt;page&nbsp;path="<code class="varname">click/error.htm</code>"&nbsp;classname="<span class="symbol">com.mycorp.page.ErrorPage</span>"/&gt;</p></div><p>When the ClickSevlet starts up it checks to see whether the
+    <code class="varname">error.htm</code> template exists in the <code class="varname">click</code>
+    web sub directory. If it cannot find the page the ClickServlet will
+    automatically deploy one. You can tailor the <code class="varname">click/error.htm</code>
+    template to suite you own tastes, and the ClickServlet will
+    not overwrite it.
+    </p><p>The default error template will display extensive debug information
+    when the application is in <code class="literal">development</code> or
+    <code class="literal">debug</code> mode. Example error page displays include:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../error-npe.html" target="_blank">NullPointerException</a> - in a page
+          method
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../error-parsing.html" target="_blank">ParseErrorException</a> - in a
+          page template
+        </p></li></ul></div><p>When the application is in <code class="literal">production</code> mode only
+    a simple error message is displayed. See
+    <a class="link" href="ch04s02.html#application-mode" title="4.2.6.&nbsp;Mode">Configuration</a> for details on how to
+    set the application mode.
+    </p><p>Please also see the <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../examples.html" target="_blank">Examples</a> web
+    app Exception Demo for demonstrations of Clicks error handling.
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s08.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s10.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">2.8.&nbsp;Stateful Pages&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;2.10.&nbsp;Page Not Found</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02s10.html b/org.apache.click.eclipse/documentation/user-guide/ch02s10.html
new file mode 100644
index 0000000..b95d010
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02s10.html
@@ -0,0 +1,16 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>2.10.&nbsp;Page Not Found</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="prev" href="ch02s09.html" title="2.9.&nbsp;Error Handling"><link rel="next" href="ch02s11.html" title="2.11.&nbsp;Page Message Properties"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2.10.&nbsp;Page Not Found</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s09.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;Pages</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s11.html">Next</a></td></tr></table><hr></div><div class="sect1" title="2.10.&nbsp;Page Not Found"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="page-not-found"></a>2.10.&nbsp;Page Not Found</h2></div></div></div><p>If the ClickServlet cannot find a requested page in the
+    <code class="literal">click.xml</code> config file it will use the registered
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../not-found.html" target="_blank">not-found.htm</a> page.
+    </p><p>The Click <code class="literal">not found page</code> is automatically configured
+    as:
+    </p><div class="literallayout"><p>&lt;page&nbsp;path="<code class="varname">click/not-found.htm</code>"&nbsp;classname="<span class="symbol">org.apache.click.Page</span>"/&gt;</p></div><p>You can override the default configuration and specify your own class,
+    but you cannot change the path.
+    </p><p>When the ClickSevlet starts up it checks to see whether the
+    <code class="varname">not-found.htm</code> template exists in the <code class="varname">click</code>
+    web sub directory. If it cannot find the page the ClickServlet will
+    automatically deploy one.
+    </p><p>You can tailor the <code class="varname">click/not-found.htm</code> template to
+    suite you own needs. This page template has access to the usual Click objects.
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s09.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s11.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">2.9.&nbsp;Error Handling&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;2.11.&nbsp;Page Message Properties</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02s11.html b/org.apache.click.eclipse/documentation/user-guide/ch02s11.html
new file mode 100644
index 0000000..8701d03
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02s11.html
@@ -0,0 +1,23 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>2.11.&nbsp;Page Message Properties</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="prev" href="ch02s10.html" title="2.10.&nbsp;Page Not Found"><link rel="next" href="ch02s12.html" title="2.12.&nbsp;Page HEAD Elements"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2.11.&nbsp;Page Message Properties</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s10.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;Pages</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch02s12.html">Next</a></td></tr></table><hr></div><div class="sect1" title="2.11.&nbsp;Page Message Properties"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="page-message-properties"></a>2.11.&nbsp;Page Message Properties</h2></div></div></div><p>The Page class provides a
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#messages" target="_blank">messages</a>
+    property which is a
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/MessagesMap.html" target="_blank">MessagesMap</a>
+    of localized messages for the page. These messages are made available in the
+    VelocityContext when the page is rendered under the key
+    <code class="literal">messages</code>. So for example if you had a page title message
+    you would access it in your page template as:
+    </p><div class="literallayout"><p>&lt;h1&gt;&nbsp;<span class="symbol">$</span><code class="varname">messages.title</code>&nbsp;&lt;/h1&gt;</p></div><p>This messages map is loaded from the page class property bundle. For
+    example if you had a page class <code class="classname">com.mycorp.page.CustomerList</code>
+    you could have an associated property file containing the pages localized
+    messages:
+    </p><div class="literallayout"><p>/com/mycorp/page/CustomerList.properties</p></div><p>You can also defined a application global page messages properties file:
+    </p><div class="literallayout"><p>/click-page.properties</p></div><p>Messages defined in this file will be available to all pages throughout
+    your application. Note messages defined in your page class properties file
+    will override any messages defined in the application global page properties
+    file.
+    </p><p>Page messages can also be used to override Control messages, see the
+    Controls <a class="link" href="ch03s04.html" title="3.4.&nbsp;Message Properties">Message Properties</a>
+    topic for more details.
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s10.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch02s12.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">2.10.&nbsp;Page Not Found&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;2.12.&nbsp;Page HEAD Elements</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch02s12.html b/org.apache.click.eclipse/documentation/user-guide/ch02s12.html
new file mode 100644
index 0000000..5feccb6
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch02s12.html
@@ -0,0 +1,75 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>2.12.&nbsp;Page HEAD Elements</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch02.html" title="Chapter&nbsp;2.&nbsp;Pages"><link rel="prev" href="ch02s11.html" title="2.11.&nbsp;Page Message Properties"><link rel="next" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Controls"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">2.12.&nbsp;Page HEAD Elements</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s11.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;2.&nbsp;Pages</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="2.12.&nbsp;Page HEAD Elements"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="page-head-elements"></a>2.12.&nbsp;Page HEAD Elements</h2></div></div></div><p>The Page class provides the method
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#getHeadElements()" target="_blank">getHeadElements()</a>
+    for contributing HEAD <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/element/Element.html" target="_blank">elements</a>
+    such as <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/element/JsImport.html" target="_blank">JsImport</a>,
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/element/JsScript.html" target="_blank">JsScript</a>,
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/element/CssImport.html" target="_blank">CssImport</a>
+    and <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/element/CssStyle.html" target="_blank">CssStyle</a>.
+    </p><p>Here is an example of adding HEAD elements to the
+    <code class="classname">MyPage</code> class:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> MyPage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> MyPage() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add the JavaScript import "/mypage.js" to the page</span>
+        getHeadElements().add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> JsImport(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/mypage.js"</span>));
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add some inline JavaScript content to the page</span>
+        getHeadElements().add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> JsScript(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"alert('Welcome to MyPage');"</span>));
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add the Css import "/mypage.css" to the page</span>
+        getHeadElements().add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> CssImport(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/mypage.css"</span>));
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add some inline Css content to the page</span>
+        getHeadElements().add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> CssStyle(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"body { font-family: Verdana; }"</span>));
+    }
+
+    ...
+
+} </pre><p>In the example above we added the HEAD elements from the Page constructor,
+    however you can add HEAD elements from anywhere in the Page including the
+    event handlers <code class="literal">onInit</code>, <code class="literal">onGet</code>,
+    <code class="literal">onPost</code>, <code class="literal">onRender</code> etc.
+    Please see <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#getHeadElements()" target="_blank">getHeadElements()</a>
+    for more details.
+    </p><p>Below is the <code class="filename">/my-page.htm</code> template:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <code class="varname">$headElements</code>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+    ...
+
+    <code class="varname">$jsElements</code>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span> </pre><p>The two variables, <code class="varname">$headElements</code> and
+    <code class="varname">$jsElements</code>, are automatically made available to the Page
+    template. These variables references the JavaScript and Css HEAD elements
+    specified in <code class="classname">MyPage</code>.
+    </p><p>The following HTML will be rendered (assuming the application context
+    is "/myapp"):
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;link</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">rel</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"stylesheet"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/css"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">href</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="symbol">/myapp/mypage.css</span>"&gt;<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/link&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;style</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">rel</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"stylesheet"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/css"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+      <span class="symbol">body { font-family: Verdana; }</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/style&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+    ...
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;script</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/javascript"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">src</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="symbol">/myapp/mypage.js</span>"/&gt;
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;script</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/javascript"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+      <span class="symbol">alert('Welcome to MyPage');</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/script&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span> </pre><p>A live demo showing how to add HEAD elements to a Page can be seen
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://www.avoka.com/click-examples/general/page-head-demo.htm" target="_blank">here</a>.
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s11.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch02.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">2.11.&nbsp;Page Message Properties&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;3.&nbsp;Controls</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch03.html b/org.apache.click.eclipse/documentation/user-guide/ch03.html
new file mode 100644
index 0000000..46d6790
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch03.html
@@ -0,0 +1,53 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>Chapter&nbsp;3.&nbsp;Controls</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="index.html" title="Apache Click"><link rel="prev" href="ch02s12.html" title="2.12.&nbsp;Page HEAD Elements"><link rel="next" href="ch03s02.html" title="3.2.&nbsp;Control Callback"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;3.&nbsp;Controls</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch02s12.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03s02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;3.&nbsp;Controls"><div class="titlepage"><div><div><h2 class="title"><a name="chapter-controls"></a>Chapter&nbsp;3.&nbsp;Controls</h2></div></div></div><div class="toc"><dl><dt><span class="sect1"><a href="ch03.html#control-interface">3.1. Control Interface</a></span></dt><dt><span class="sect1"><a href="ch03s02.html">3.2. Control Callback</a></span></dt><dt><span class="sect1"><a href="ch03s03.html">3.3. Control Classes</a></span></dt><dt><span class="sect1"><a href="ch03s04.html">3.4. Message Properties</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch03s04.html#message-resolution">3.4.1. Message Resolution</a></span></dt><dt><span class="sect2"><a href="ch03s04.html#control-properties">3.4.2. Control Properties</a></span></dt><dt><span class="sect2"><a href="ch03s04.html#accessing-messages">3.4.3. Accessing Messages</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch03s05.html">3.5. Control HEAD Elements</a></span></dt><dt><span class="sect1"><a href="ch03s06.html">3.6. Container</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch03s06.html#abstractcontainer">3.6.1. AbstractContainer</a></span></dt><dt><span class="sect2"><a href="ch03s06.html#abstractcontainerfield">3.6.2. AbstractContainerField</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch03s07.html">3.7. Layouts</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch03s07.html#template-layout">3.7.1. Template layout</a></span></dt><dt><span class="sect2"><a href="ch03s07.html#programmatic-layout">3.7.2. Programmatic layout</a></span></dt></dl></dd></dl></div><p>Apache Click provides a rich set of Controls which support client side
+  rendering and server side processing. Please see the
+  <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/package-summary.html" target="_blank">Javadoc</a>,
+  which provides extensive information and examples of the core Controls.
+  </p><p>This chapter covers Control in detail including the Control life cycle,
+  Control event callbacks and localization.
+
+  </p><div class="sect1" title="3.1.&nbsp;Control Interface"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="control-interface"></a>3.1.&nbsp;Control Interface</h2></div></div></div><p> Controls provide the server side components that process user input,
+    and render their display to the user. Controls are equivalent to Visual
+    Basic Controls or Delphi Components.
+    </p><p>Controls handle the processing of user input in the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#onProcess()" target="_blank">onProcess</a>
+    method and render their HTML display using the toString() method. The
+    execution sequence for a Control being processed and rendered is illustrated
+    in the figure below.
+    </p><div class="figure"><a name="control-post-sequence-diagram"></a><div class="figure-contents"><span class="inlinemediaobject"><img src="images/controls/control-post-sequence-diagram.png" alt="Post Sequence Diagram"></span></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;3.1.&nbsp;Post Sequence Diagram
+      </i></p></div><br class="figure-break"><p>In Click all control classes must implement the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html" target="_blank">Control</a> interface.
+    The Control interface is depicted in the figure below.
+    </p><div class="figure"><a name="control-class-diagram"></a><div class="figure-contents"><span class="inlinemediaobject"><img src="images/controls/control-class-diagram.png" alt="Control Interface Diagram"></span></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;3.2.&nbsp;Control Interface Diagram
+      </i></p></div><br class="figure-break"><p>Methods on the Control interface include:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#getHeadElements" target="_blank">getHeadElements()</a>
+          - defines the controls HTML header imports.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#getMessages()" target="_blank">getMessages()</a>
+          - defines the controls localized messages map.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#getName()" target="_blank">getName()</a> /
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#setName(java.lang.String)" target="_blank">setName()</a>
+          &nbsp; - &nbsp; defines the controls name in the Page model or Form fields.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#getParent()" target="_blank">getParent()</a> /
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#setParent(java.lang.Object)" target="_blank">setParent()</a>
+          &nbsp; - &nbsp; defines the controls parent.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#onDeploy(javax.servlet.ServletContext)" target="_blank">onDeploy()</a>
+          - deploy resources on startup.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#onInit()" target="_blank">onInit()</a>
+          - on initialize event handler.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#onProcess()" target="_blank">onProcess()</a>
+          - process request event handler.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#onDestroy()" target="_blank">onDestroy()</a>
+          - on destroy event handler.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#render(org.apache.click.util.HtmlStringBuffer)" target="_blank">render()</a>
+          - generate the control's HTML representation.
+        </p></li></ul></div></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch02s12.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03s02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">2.12.&nbsp;Page HEAD Elements&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;3.2.&nbsp;Control Callback</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch03s02.html b/org.apache.click.eclipse/documentation/user-guide/ch03s02.html
new file mode 100644
index 0000000..b8fa7a1
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch03s02.html
@@ -0,0 +1,57 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>3.2.&nbsp;Control Callback</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Controls"><link rel="prev" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Controls"><link rel="next" href="ch03s03.html" title="3.3.&nbsp;Control Classes"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">3.2.&nbsp;Control Callback</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;3.&nbsp;Controls</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03s03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="3.2.&nbsp;Control Callback"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="control-callback"></a>3.2.&nbsp;Control Callback</h2></div></div></div><p>Click Controls provide an event callback mechanism similar to a
+    <code class="classname">java.awt.ActionListener</code> callback.
+    </p><p>Click supports two styles of action listeners. The first is using the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/ActionListener.html" target="_blank">ActionListener</a>
+    interface and
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/AbstractControl.html#setActionListener(org.apache.click.ActionListener)" target="_blank">setActionListener(ActionListener)</a>
+    method which provides compile time safety.
+    </p><p>The second is to register the action listener via the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#setListener(java.lang.Object, java.lang.String)" target="_blank">setListener(Object, String)</a>
+    method where you specify the call back method via its name. This second style
+    uses less lines of code, but has no compile time safety.
+    </p><p>Examples of these two action listener styles are provided below:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> ActionDemo <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> BorderPage {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Uses listener style 1</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> ActionLink link = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> ActionLink();
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Uses listener style 2</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> ActionButton button = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> ActionButton();
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> ActionDemo() {
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Verbose but provides compile time safety</span>
+        link.setActionListener(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> ActionListener() {
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onAction(Control source) {
+                <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> onLinkClick(source);
+            }
+        });
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Succinct but typos will cause runtime errors</span>
+        button.setListener(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">this</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"onButtonClick"</span>);
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Event Handlers ---------------------------------------------------------</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onLinkClick(Control source) {
+        ..
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> true;
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onButtonClick() {
+        ..
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> true;
+    }
+}</pre><p>All call back listener methods must return a boolean value. If they
+    return true the further processing of other controls and page methods should
+    continue. Otherwise if they return false, then any further processing should
+    be aborted. By returning false you can effectively exit at this point and
+    redirect or forward to another page. This execution logic is illustrated in
+    the <a class="link" href="ch02s02.html#activity-diagram" title="Figure&nbsp;2.3.&nbsp;Page Execution Activity Diagram">Page Execution Activity Diagram</a>.
+    </p><p>Being able to stop further processing and do something else can be very
+    handy. For example your Pages onRender() method may perform an expensive database
+    operation. By returning false in an event handler you can skip this step and
+    render the template or forward to the next page.
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch03.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03s03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;3.&nbsp;Controls&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;3.3.&nbsp;Control Classes</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch03s03.html b/org.apache.click.eclipse/documentation/user-guide/ch03s03.html
new file mode 100644
index 0000000..19f47ec
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch03s03.html
@@ -0,0 +1,34 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>3.3.&nbsp;Control Classes</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Controls"><link rel="prev" href="ch03s02.html" title="3.2.&nbsp;Control Callback"><link rel="next" href="ch03s04.html" title="3.4.&nbsp;Message Properties"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">3.3.&nbsp;Control Classes</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;3.&nbsp;Controls</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03s04.html">Next</a></td></tr></table><hr></div><div class="sect1" title="3.3.&nbsp;Control Classes"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="control-class"></a>3.3.&nbsp;Control Classes</h2></div></div></div><p>Core control classes are defined in the package
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/package-summary.html" target="_blank">org.apache.click.control</a>.
+    This package includes controls for the essential HTML elements.
+    </p><p>Extended control classes are provided in the Click Extras package
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/control/package-summary.html" target="_blank">org.apache.click.extras.control</a>.
+    Click Extras classes can contain dependencies to 3rd party frameworks.
+    </p><p>A subset of these control classes are depicted in the figure below.
+    </p><div class="figure"><a name="control-package-class-diagram"></a><div class="figure-contents"><span class="inlinemediaobject"><img src="images/controls/control-package-class-diagram.png" alt="Package Class Diagram"></span></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;3.3.&nbsp;Package Class Diagram
+      </i></p></div><br class="figure-break"><p>The key control classes include:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/ActionLink.html" target="_blank">ActionLink</a>
+          - provides an anchor link which can invoke callback listeners.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Field.html" target="_blank">Field</a>
+          - provides the abstract form field control.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Form.html" target="_blank">Form</a>
+          - provides a form control for processing, validation and rendering.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Submit.html" target="_blank">Submit</a>
+          - provides an input type submit control which can invoke callback listeners.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/TextField.html" target="_blank">TextField</a>
+          - provides an input type text control which can invoke callback listeners.
+        </p></li></ul></div><p>The control classes are designed to support subclassing for customized
+    behaviour. All control fields have protected visibility and have public
+    accessor methods.
+    </p><p>You can also aggregate controls to build more complex controls. For
+    example the <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/control/CreditCardField.html" target="_blank">CreditCardField</a>
+    uses a <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Select.html" target="_blank">Select</a>
+    control to render the different credit card types.
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03s02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch03.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03s04.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">3.2.&nbsp;Control Callback&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;3.4.&nbsp;Message Properties</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch03s04.html b/org.apache.click.eclipse/documentation/user-guide/ch03s04.html
new file mode 100644
index 0000000..3079035
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch03s04.html
@@ -0,0 +1,102 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>3.4.&nbsp;Message Properties</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Controls"><link rel="prev" href="ch03s03.html" title="3.3.&nbsp;Control Classes"><link rel="next" href="ch03s05.html" title="3.5.&nbsp;Control HEAD Elements"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">3.4.&nbsp;Message Properties</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03s03.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;3.&nbsp;Controls</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03s05.html">Next</a></td></tr></table><hr></div><div class="sect1" title="3.4.&nbsp;Message Properties"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="control-message-properties"></a>3.4.&nbsp;Message Properties</h2></div></div></div><p>Control strings for field validation messages and HTML formatting
+    strings are externalized in the properties file. By using these properties
+    files you can localize a Click application for your particular language and
+    dialect.
+    </p><div class="sect2" title="3.4.1.&nbsp;Message Resolution"><div class="titlepage"><div><div><h3 class="title"><a name="message-resolution"></a>3.4.1.&nbsp;Message Resolution</h3></div></div></div><p>Messages are looked up in a particular order enabling taylor specific
+      messages, for your controls, individual pages or across your entire
+      application. The order in which localized messages are resolved is:
+      </p><div class="variablelist"><dl><dt><span class="term"><span class="bold"><strong>Page scope messages</strong></span></span></dt><dd><p>Message lookups are first resolved to the Page classes message
+            bundle if it exists. For example a <code class="classname">Login</code> page
+            may define the message properties:
+            </p><div class="literallayout"><p>/com/mycorp/page/Login.properties</p></div><p>If you want to tailor messages for a particular page this is
+            where to place them.
+            </p></dd><dt><span class="term"><span class="bold"><strong>Global page scope messages</strong></span></span></dt><dd><p>Next message lookups are resolved to the global pages message
+            bundle if it exists.
+            </p><div class="literallayout"><p>/click-page.properties</p></div><p>If you want messages to be used across your entire application
+            this is where to place them.
+            </p></dd><dt><span class="term"><span class="bold"><strong>Control scope messages</strong></span></span></dt><dd><p>Next message lookups are resolved to the Control classes
+            message bundle if it exists. For example a
+            <code class="classname">CustomTextField</code> control may define the
+            message properties:
+            </p><div class="literallayout"><p>/com/mycorp/control/CustomTextField.properties</p></div><p>A custom control's messages can be placed here
+            (or the global control scope covered next) and overridden by one of the
+            above options.
+            </p></dd><dt><span class="term"><span class="bold"><strong>Global control scope messages</strong></span></span></dt><dd><p>Finally message lookups are resolved to the global application
+            control message bundle if the message has not already been found.
+            The global control properties file is:
+            </p><div class="literallayout"><p>/click-control.properties</p></div><p>Control messages can be placed here and overridden by one of
+            the above options.
+            </p></dd></dl></div></div><div class="sect2" title="3.4.2.&nbsp;Control Properties"><div class="titlepage"><div><div><h3 class="title"><a name="control-properties"></a>3.4.2.&nbsp;Control Properties</h3></div></div></div><p>To customize the <code class="filename">click-control.properties</code> simply
+      add this file to your classpath and tailor the specific values.
+      </p><p>Note when customizing the message properties you must include all
+      the properties, not just the ones you want to override.
+      </p><div class="literallayout"><p>#&nbsp;Click&nbsp;Control&nbsp;messages<br>
+field-maxlength-error={0}&nbsp;must&nbsp;be&nbsp;no&nbsp;longer&nbsp;than&nbsp;{1}&nbsp;characers<br>
+field-minlength-error={0}&nbsp;must&nbsp;be&nbsp;at&nbsp;least&nbsp;{1}&nbsp;characters<br>
+field-required-error=You&nbsp;must&nbsp;enter&nbsp;a&nbsp;value&nbsp;for&nbsp;{0}<br>
+<br>
+file-required-error=You&nbsp;must&nbsp;enter&nbsp;a&nbsp;filename&nbsp;for&nbsp;{0}<br>
+<br>
+label-required-prefix=<br>
+label-required-suffix=&lt;span&nbsp;class="required"&gt;*&lt;/span&gt;<br>
+label-not-required-prefix=<br>
+label-not-required-suffix=&amp;nbsp;<br>
+<br>
+not-checked-error=You&nbsp;must&nbsp;select&nbsp;{0}<br>
+<br>
+number-maxvalue-error={0}&nbsp;must&nbsp;not&nbsp;be&nbsp;larger&nbsp;than&nbsp;{1}<br>
+number-minvalue-error={0}&nbsp;must&nbsp;not&nbsp;be&nbsp;smaller&nbsp;than&nbsp;{1}<br>
+<br>
+select-error=You&nbsp;must&nbsp;select&nbsp;a&nbsp;value&nbsp;for&nbsp;{0}<br>
+<br>
+table-first-label=First<br>
+table-first-title=Go&nbsp;to&nbsp;first&nbsp;page<br>
+table-previous-label=Prev<br>
+table-previous-title=Go&nbsp;to&nbsp;previous&nbsp;page<br>
+table-next-label=Next<br>
+table-next-title=Go&nbsp;to&nbsp;next&nbsp;page<br>
+table-last-label=Last<br>
+table-last-title=Go&nbsp;to&nbsp;last&nbsp;page<br>
+table-goto-title=Go&nbsp;to&nbsp;page<br>
+table-page-banner=&lt;span&nbsp;class="pagebanner"&gt;{0}&nbsp;items&nbsp;found,&nbsp;displaying&nbsp;{1}&nbsp;to&nbsp;{2}.&lt;/span&gt;<br>
+table-page-banner-nolinks=<br>
+&nbsp;&nbsp;&lt;span&nbsp;class="pagebanner-nolinks"&gt;{0}&nbsp;items&nbsp;found,&nbsp;displaying&nbsp;{1}&nbsp;to&nbsp;{2}.&lt;/span&gt;<br>
+table-page-links=&lt;span&nbsp;class="pagelinks"&gt;[{0}/{1}]&nbsp;{2}&nbsp;[{3}/{4}]&lt;/span&gt;<br>
+table-page-links-nobanner=&lt;span&nbsp;class="pagelinks-nobanner"&gt;[{0}/{1}]&nbsp;{2}&nbsp;[{3}/{4}]&lt;/span&gt;<br>
+table-no-rows-found=No&nbsp;records&nbsp;found.<br>
+<br>
+table-inline-first-image=/click/paging-first.gif<br>
+table-inline-first-disabled-image=/click/paging-first-disabled.gif<br>
+table-inline-previous-image=/click/paging-prev.gif<br>
+table-inline-previous-disabled-image=/click/paging-prev-disabled.gif<br>
+table-inline-next-image=/click/paging-next.gif<br>
+table-inline-next-disabled-image=/click/paging-next-disabled.gif<br>
+table-inline-last-image=/click/paging-last.gif<br>
+table-inline-last-disabled-image=/click/paging-last-disabled.gif<br>
+table-inline-page-links=Page&nbsp;&nbsp;&nbsp;{0}&nbsp;{1}&nbsp;{2}&nbsp;{3}&nbsp;{4}<br>
+<br>
+#&nbsp;Message&nbsp;displayed&nbsp;when&nbsp;a&nbsp;error&nbsp;occurs&nbsp;when&nbsp;the&nbsp;application&nbsp;is&nbsp;in&nbsp;"production"&nbsp;mode<br>
+production-error-message=<br>
+&nbsp;&nbsp;&lt;div&nbsp;id='errorReport'&nbsp;class='errorReport'&gt;The&nbsp;application&nbsp;encountered&nbsp;an&nbsp;unexpected&nbsp;error.<br>
+&nbsp;&nbsp;&lt;/div&gt;<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</p></div></div><div class="sect2" title="3.4.3.&nbsp;Accessing Messages"><div class="titlepage"><div><div><h3 class="title"><a name="accessing-messages"></a>3.4.3.&nbsp;Accessing Messages</h3></div></div></div><p>Field classes support a hierarchy of resource bundles for displaying
+      validation error messages and display messages. These localized messages
+      can be accessed through the Field methods:
+      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/AbstractControl.html#getMessage(java.lang.String)" target="_blank">getMessage(String)</a>
+          </p></li><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/AbstractControl.html#getMessage(java.lang.String,%20java.lang.Object)" target="_blank">getMessage(String, Object)</a>
+          </p></li><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/AbstractControl.html#getMessage(java.lang.String,%20java.lang.Object[])" target="_blank">getMessage(String, Object[])</a>
+          </p></li><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/AbstractControl.html#getMessages()" target="_blank">getMessages()</a>
+          </p></li><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Field.html#setErrorMessage(java.lang.String)" target="_blank">setErrorMessage(String)</a>
+          </p></li><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Field.html#setErrorMessage(java.lang.String,%20java.lang.Object)" target="_blank">setErrorMessage(String, Object)</a>
+          </p></li></ul></div><p>These methods use the <code class="literal">Locale</code> of the request to
+      lookup the string resource bundle, and use <code class="classname">MessageFormat</code>
+      for any string formatting.
+      </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03s03.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch03.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03s05.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">3.3.&nbsp;Control Classes&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;3.5.&nbsp;Control HEAD Elements</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch03s05.html b/org.apache.click.eclipse/documentation/user-guide/ch03s05.html
new file mode 100644
index 0000000..b2a78fd
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch03s05.html
@@ -0,0 +1,69 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>3.5.&nbsp;Control HEAD Elements</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Controls"><link rel="prev" href="ch03s04.html" title="3.4.&nbsp;Message Properties"><link rel="next" href="ch03s06.html" title="3.6.&nbsp;Container"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">3.5.&nbsp;Control HEAD Elements</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03s04.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;3.&nbsp;Controls</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03s06.html">Next</a></td></tr></table><hr></div><div class="sect1" title="3.5.&nbsp;Control HEAD Elements"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="control-head-elements"></a>3.5.&nbsp;Control HEAD Elements</h2></div></div></div><p>The Control interface provides the method
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#getHeadElements()" target="_blank">getHeadElements()</a>
+    which allows the Control to add Page HEAD
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/element/Element.html" target="_blank">elements</a>
+    such as <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/element/JsImport.html" target="_blank">JsImport</a>,
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/element/JsScript.html" target="_blank">JsScript</a>,
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/element/CssImport.html" target="_blank">CssImport</a>
+    and <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/element/CssStyle.html" target="_blank">CssStyle</a>.
+    </p><p>Here is an example of adding HEAD elements to a custom
+    <code class="classname">Control</code>:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> MyControl <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> AbstractControl {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> MyControl() {
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+         * Override the default getHeadElements implementation to return
+         * MyControl's list of HEAD elements.
+         *
+         * Note that the variable headElements is defined in AbstractControl.
+         *
+         * @return list the list of HEAD elements
+         */</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> List getHeadElements() {
+
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Use lazy loading to only add the HEAD elements once and when needed.</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (headElements == null) {
+
+                <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Get the head elements from the super implementation</span>
+                headElements = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">super</span>.getHeadElements();
+
+                <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add the JavaScript import "/mycontrol.js" to the control</span>
+                headElements.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> JsImport(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/mycontrol.js"</span>));
+
+                <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add the Css import "/mycontrol.css" to the control</span>
+                headElements.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> CssImport(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/mycontrol.css"</span>));
+            }
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> headElements;
+        }
+    }
+
+    ...
+
+} </pre><p>In the example above we added the HEAD elements by overriding the
+    Control's <code class="methodname">getHeadElements</code> method, however you can
+    add HEAD elements from anywhere in the Control including the event handlers
+    <code class="literal">onInit</code>, <code class="literal">onGet</code>,
+    <code class="literal">onPost</code>, <code class="literal">onRender</code> etc.
+    Please see <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#getHeadElements()" target="_blank">getHeadElements()</a>
+    for more details.
+    </p><p><code class="classname">MyControl</code> will add the following HEAD elements
+    to the Page HEAD section, together with HEAD elements added by the Page and
+    other controls (assume the application context is "/myapp"):
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;link</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">rel</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"stylesheet"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/css"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">href</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="symbol">/myapp/mycontrol.css</span>"&gt;<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/link&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+    ...
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;script</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/javascript"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">src</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="symbol">/myapp/mycontrol.js</span>"/&gt;
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span> </pre><p>A live demo showing how to add HEAD elements from a custom Control can
+  be seen <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://www.avoka.com/click-examples/general/control-head-demo.htm" target="_blank">here</a>.
+  </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03s04.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch03.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03s06.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">3.4.&nbsp;Message Properties&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;3.6.&nbsp;Container</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch03s06.html b/org.apache.click.eclipse/documentation/user-guide/ch03s06.html
new file mode 100644
index 0000000..b8543fa
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch03s06.html
@@ -0,0 +1,93 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>3.6.&nbsp;Container</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Controls"><link rel="prev" href="ch03s05.html" title="3.5.&nbsp;Control HEAD Elements"><link rel="next" href="ch03s07.html" title="3.7.&nbsp;Layouts"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">3.6.&nbsp;Container</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03s05.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;3.&nbsp;Controls</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch03s07.html">Next</a></td></tr></table><hr></div><div class="sect1" title="3.6.&nbsp;Container"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="container"></a>3.6.&nbsp;Container</h2></div></div></div><p><a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Container.html" target="_blank">Container</a>
+    is a Control that can contain other Controls, thus forming a hierarchy
+    of components. Container enables components to add, remove and retrieve other
+    controls. Listed below are example Containers:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Form.html" target="_blank">Form</a>
+          - an HTML form which provides default layout of fields and error feedback.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Panel.html" target="_blank">Panel</a>
+          - similar to
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html" target="_blank">Page</a>, this
+          Container provides its own template and model.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/FieldSet.html" target="_blank">FieldSet</a>
+          - draws a legend (border) around its child Controls.
+        </p></li></ul></div><p>These Containers are depicted in the figure below.
+    </p><div class="figure"><a name="container-package-class-diagram"></a><div class="figure-contents"><span class="inlinemediaobject"><img src="images/controls/container-package-class-diagram.png" alt="Container Class Diagram"></span></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;3.4.&nbsp;Container Class Diagram</i></p></div><br class="figure-break"><p>The following classes provides convenient extension points for creating
+    custom Containers:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/AbstractContainer.html" target="_blank">AbstractContainer</a>
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/control/AbstractContainerField.html" target="_blank">AbstractContainerField</a>
+        </p></li></ul></div><p>Lets cover each of them here.
+    </p><div class="sect2" title="3.6.1.&nbsp;AbstractContainer"><div class="titlepage"><div><div><h3 class="title"><a name="abstractcontainer"></a>3.6.1.&nbsp;AbstractContainer</h3></div></div></div><p>Enables easy creation of custom Containers, for example an html
+      <span class="emphasis"><em>div</em></span> or <span class="emphasis"><em>span</em></span> element:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> Div <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> AbstractContainer {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> Div(String name) {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">super</span>(name);
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> String getTag() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Return the control's HTML tag.</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"div"</span>;
+    }
+}</pre><p>Lets try out the newly created <code class="classname">Container</code>
+      above: (note the <code class="classname">MockContext</code> used in this test is
+      described in the <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../mock-api/overview-summary.html" target="_blank">Mock Test Support</a>
+      documentation)
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> Test {
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">static</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> main (String args[]) {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create mock context in which to test the container.</span>
+        MockContext.initContext();
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create a div instance called "mydiv"</span>
+        String containerName = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"mydiv"</span>;
+        Div mydiv = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Div(containerName);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add a control to the container</span>
+        mydiv.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> TextField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"myfield"</span>));
+
+        System.out.println(mydiv);
+    }
+}</pre><p>Executing the above example results in the following output:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;div</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"mydiv"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"mydiv"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;input</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"myfield"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"myfield"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">""</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">size</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"20"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag"> /&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/div&gt;</span></pre></div><div class="sect2" title="3.6.2.&nbsp;AbstractContainerField"><div class="titlepage"><div><div><h3 class="title"><a name="abstractcontainerfield"></a>3.6.2.&nbsp;AbstractContainerField</h3></div></div></div><p>AbstractContainerField extends Field and implements the Container
+      interface. This provides a convenient base class in case you run into
+      a situation where you need both a Field and Container.
+      </p><p>Below is an example of how AbstractContainerField might be used:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> FieldAndContainer <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> AbstractContainerField {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> FieldAndContainer(String name) {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">super</span>(name);
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Return the html tag to render</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> String getTag() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"div"</span>;
+    }
+}</pre><p>To test the new class we use the following snippet:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> Test {
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">static</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> main (String args[]) {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create mock context in which to test the container.</span>
+        MockContext.initContext();
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create a FieldContainer instance called "field_container"</span>
+        String containerName = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"field_container"</span>;
+        FieldAndContainer fieldAndContainer = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> FieldAndContainer(containerName);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add a couple of fields to the container</span>
+        fieldAndContainer.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> TextField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"myfield"</span>));
+        fieldAndContainer.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> TextArea(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"myarea"</span>));
+
+        System.out.println(fieldAndContainer);
+    }
+}</pre><p>Executing the snippet produces the output:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;div</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"field_container"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"field_container"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;input</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"myfield"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"myfield"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">""</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">size</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"20"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;textarea</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"myarea"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"myarea"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">rows</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"3"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">cols</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"20"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/textarea&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/div&gt;</span></pre></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03s05.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch03.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch03s07.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">3.5.&nbsp;Control HEAD Elements&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;3.7.&nbsp;Layouts</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch03s07.html b/org.apache.click.eclipse/documentation/user-guide/ch03s07.html
new file mode 100644
index 0000000..f73b0c4
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch03s07.html
@@ -0,0 +1,260 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>3.7.&nbsp;Layouts</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch03.html" title="Chapter&nbsp;3.&nbsp;Controls"><link rel="prev" href="ch03s06.html" title="3.6.&nbsp;Container"><link rel="next" href="ch04.html" title="Chapter&nbsp;4.&nbsp;Configuration"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">3.7.&nbsp;Layouts</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03s06.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;3.&nbsp;Controls</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch04.html">Next</a></td></tr></table><hr></div><div class="sect1" title="3.7.&nbsp;Layouts"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="layout"></a>3.7.&nbsp;Layouts</h2></div></div></div><p>Controls such as <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Form.html" target="_blank">Form</a>
+    takes care of layout and error reporting automatically, and for many use
+    cases the auto-layout approach is good enough. It is certainly very productive.
+    </p><p>However for custom or complex layouts, auto-layout is not always the best
+    choice. There are two approaches for creating custom layouts.
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Template approach - use a template engine such as Velocity,
+        Freemarker or JSP to declare the layout as HTML markup.
+        </p></li><li class="listitem"><p> Programmatic approach - build custom layout components using Java.
+        This option is very similar to building components using Swing.
+        </p></li></ul></div><div class="sect2" title="3.7.1.&nbsp;Template layout"><div class="titlepage"><div><div><h3 class="title"><a name="template-layout"></a>3.7.1.&nbsp;Template layout</h3></div></div></div><p>The <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Form.html#manual-layout" target="_blank">Template</a>
+      approach separates the Page and layout logic. The Page is used to implement
+      the presentation logic such as creating controls, registering listeners
+      and copying data to domain objects, while the template is used to layout
+      the Page controls.
+      </p><p>Lets walk through an example using the template approach. Below
+      we create an EmployeePage which contains a Form and a bunch of fields
+      and submit button.
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// EmployeePage.java</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> EmployeePage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> Form form;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onInit() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create form</span>
+        Form form = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Form(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"form"</span>);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add a couple of fields to the form</span>
+        form.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> TextField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"firstname"</span>));
+        form.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> TextField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"lastname"</span>));
+        form.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> IntegerField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"age"</span>));
+        form.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> DoubleField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"salary"</span>));
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add a submit button to form</span>
+        form.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Submit(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"submit"</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Add Employee"</span>));
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add form the page</span>
+        addControl(form);
+    }
+}</pre><p>Lets imagine we want to create a layout using the HTML tags,
+      &lt;div&gt; and &lt;ol&gt;.
+      </p><p>We would then provide the markup for the <code class="varname">employee.htm</code>
+      template as shown below, using a template engine such as Velocity:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">&lt;!-- employee.htm --&gt;</span>
+${form.startTag()}
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;div</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">style</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"margin: 1em;"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;ol&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;li&gt;</span>
+                <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;label</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">for</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"firstname"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>Firstname:<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/label&gt;</span>
+                ${form.fields.firstname}
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/li&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;li&gt;</span>
+                <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;label</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">for</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"lastname"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>Lastname:<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/label&gt;</span>
+                ${form.fields.lastname}
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/li&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;li&gt;</span>
+                <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;label</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">for</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"age"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>Age:<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/label&gt;</span>
+                ${form.fields.age}
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/li&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;li&gt;</span>
+                <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;label</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">for</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"salary"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>Salary:<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/label&gt;</span>
+                ${form.fields.salary}
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/li&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/ol&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/div&gt;</span>
+    ${form.fields.submit}
+${form.endTag()}</pre><p>Using CSS the markup above can further be styled and transformed
+      into a nice looking form.
+      </p><p>There are pros and cons to using the template approach.
+      </p><p>One of the advantages is that the layout is explicit and one can
+      easily tweak it if needed. For example instead of using divs and ordered
+      lists, one can change the template to leverage a table layout.
+      </p><p>A disadvantage is added redundancy. In the example above we created
+      the fields in Java, and laid them out using markup in the template. If the
+      requirements should change to add a new field for example, one will have to
+      add the field in the Page as well as the template.
+      </p><p>However it is possible to "generify" the layout using template
+      engines such as Velocity, Freemarker and JSP.
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/control/Form.html#velocity-macros" target="_blank">Macro.vm</a>
+      is an example of a generic form layout using Velocity.
+      </p></div><div class="sect2" title="3.7.2.&nbsp;Programmatic layout"><div class="titlepage"><div><div><h3 class="title"><a name="programmatic-layout"></a>3.7.2.&nbsp;Programmatic layout</h3></div></div></div><p>To combat the redundancy introduced by the Template approach, you can
+      take a programmatic approach and use normal Java and some Click classes to
+      build custom layouts.
+      </p><p>Click extras provides two useful classes in this situation namely,
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/control/HtmlForm.html" target="_blank">HtmlForm</a>
+      and <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/control/HtmlFieldSet.html" target="_blank">HtmlFieldSet</a>.
+      </p><p>Unlike Form and FieldSet which renders its controls using a Table
+      layout, HtmlForm and HtmlFieldSet renders its controls in the order they
+      were added and does not add any extra markup. HtmlForm will be used in the
+      examples below.
+      </p><p>To make it easy to compare the two layout approaches we will recreate
+      the example from the template layout section, but using the programmatic
+      approach.
+      </p><p>When creating custom layouts, the HTML construct List &lt;ul&gt; is
+      pretty useful. Since Click does not provide this component, we will create
+      it as shown below. First we create the HTML list element &lt;ol&gt;, to
+      which list item elements &lt;li&gt; can be added:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// HtmlList.java</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> HtmlList <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> AbstractContainer {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> String getTag() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"ol"</span>;
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Can only add ListItems: &lt;li&gt; tags</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> Control add(Control control) {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (!(control <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">instanceof</span> ListItem)) {
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">throw</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> IllegalArgumentException(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Only list items can be added."</span>);
+        }
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">super</span>.add(control);
+    }
+}</pre><p>Next we create the HTML list item element &lt;li&gt;:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// ListItem.java</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> ListItem <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> AbstractContainer {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> String getTag() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"li"</span>;
+    }
+}</pre><p>Another component that will be used in the example is a FieldLabel
+      which renders an HTML label element for a target Field.
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// FieldLabel.java</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> FieldLabel <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> AbstractControl {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> Field target;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> String label;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> FieldLabel(Field target, String label) {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">this</span>.target = target;
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">this</span>.label = label;
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> String getTag() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"label"</span>;
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Override render to produce an html label for the specified field.</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> render(HtmlStringBuffer buffer) {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Open tag: &lt;label</span>
+        buffer.elementStart(getTag());
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Set attribute to target field's id</span>
+        setAttribute(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"for"</span>, target.getId());
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Render the labels attributes</span>
+        appendAttributes(buffer);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Close tag: &lt;label for="firstname"&gt;</span>
+        buffer.closeTag();
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add label text: &lt;label for="firstname"&gt;Firstname:</span>
+        buffer.append(label);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Close tag: &lt;label for="firstname"&gt;Firstname:&lt;/label&gt;</span>
+        buffer.elementEnd(getTag());
+    }
+
+}</pre><p>Now the form can be assembled. Continuing with the employee example
+      from the <a class="link" href="ch03s07.html#template-layout" title="3.7.1.&nbsp;Template layout">template approach</a>, we again
+      create an <code class="classname">EmployeePage</code>, but this time an
+      <code class="classname">HtmlForm</code> and <code class="classname">HtmlList</code> is used
+      to create the custom layout:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// EmployeePage.java</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> EmployeePage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// A form instance variable</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> HtmlForm form;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Build the form when the page is initialized</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onInit() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create an HtmlForm which is ideal for composing manual layouts</span>
+        form = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> HtmlForm(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"form"</span>);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create a list and add it to the form.</span>
+        HtmlList list = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> HtmlList();
+        form.add(list);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add firstname field and pass in its name, label and the list to add the field to</span>
+        addTextField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"firstname"</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Firstname:"</span>, list);
+        addTextField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"lastname"</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Lastname:"</span>, list);
+        addTextField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"age"</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Age:"</span>, list);
+        addTextField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"salary"</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Salary:"</span>, list);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add a submit button to form</span>
+        form.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Submit(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"submit"</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"Add Employee"</span>));
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Add the form to the page</span>
+        addControl(form);
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Provide a helper method to add fields to the form</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> addTextField(String nameStr, String labelStr, List list) {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create a new ListItem &lt;li&gt; and add it to the List</span>
+        ListItem item = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> ListItem();
+        list.add(item);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create a textfield with the specified name</span>
+        Field field = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> TextField(nameStr);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Create a field label, which associates the label with the field id.</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// label.toString would output: &lt;label for="firstname"&gt;Firstname:&lt;/name&gt;</span>
+        FieldLabel label = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> FieldLabel(field, labelStr);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Next add the label and field to the list item.</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// item.toString would then produce:</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// &lt;li&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">//   &lt;label for="firstname"&gt;Firstname:&lt;/name&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">//   &lt;input type="text" name="firstname" id="form_firstname" value="" size="20"/&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// &lt;/li&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">//</span>
+        item.add(label);
+        item.add(field);
+    }
+}</pre><p>And lastly the <code class="filename">employee.htm</code> template would only
+      need to specify the name of the top level component, in this case
+      <code class="varname">form</code>.
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">&lt;!--employee.htm--&gt;</span>
+<code class="varname">${form}</code></pre><p>which produces the following markup:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;form</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">method</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"post"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"form"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">action</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"/myapp/employee.htm"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;input</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"hidden"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"form_name"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"form_form_name"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"form"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;ol&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;li&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;label</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">for</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"firstname"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>Firstname:<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/label&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;input</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"firstname"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"form_firstname"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">""</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">size</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"20"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/li&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;li&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;label</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">for</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"lastname"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>Lastname:<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/label&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;input</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"lastname"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"form_lastname"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">""</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">size</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"20"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/li&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;li&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;label</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">for</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"age"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>Age:<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/label&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;input</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"age"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"form_age"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">""</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">size</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"20"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/li&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;li&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;label</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">for</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"salary"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>Salary:<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/label&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;input</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"salary"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"form_salary"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">""</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">size</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"20"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/li&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/ol&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;input</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"submit"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"submit"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">id</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"form_submit"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Add Employee"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/form&gt;</span></pre><p>Again using a CSS stylesheet, the markup above can be styled and
+      transformed into a fancy looking form.
+      </p><p>There is a <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://www.avoka.com/click-examples/form/contact-details.htm" target="_blank">live demo</a>
+      showing the programmatic approach.
+      </p><p>The advantage of the programmatic approach is that there is no
+      redundancy. Each Field is created and added using normal Java. There is no
+      need to specify where the Field must reside in the markup.
+      </p><p>If new requirements arrive and more fields added, only the Page needs
+      to change. There is no need to change the template as the layout is taken
+      care of by CSS and the markup produced by the components.
+      </p><p>Disadvantages are that more upfront work is needed to write the
+      components and it is more difficult to
+      <span class="emphasis"><em>visualize</em></span> what output would be rendered by the
+      components.
+      </p><p>However once your custom layout components are in place, it can be
+      reused across your project and boost productivity.
+      </p><p>Whether you use the <a class="link" href="ch03s07.html#template-layout" title="3.7.1.&nbsp;Template layout">template</a>
+      or <a class="link" href="ch03s07.html#programmatic-layout" title="3.7.2.&nbsp;Programmatic layout">programmatic</a> layout approach,
+      is up to you. Both work well and have advantages and disadvantages over the
+      other.
+      </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03s06.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch03.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch04.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">3.6.&nbsp;Container&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;4.&nbsp;Configuration</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch04.html b/org.apache.click.eclipse/documentation/user-guide/ch04.html
new file mode 100644
index 0000000..c65102e
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch04.html
@@ -0,0 +1,86 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>Chapter&nbsp;4.&nbsp;Configuration</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="index.html" title="Apache Click"><link rel="prev" href="ch03s07.html" title="3.7.&nbsp;Layouts"><link rel="next" href="ch04s02.html" title="4.2.&nbsp;Application Configuration"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;4.&nbsp;Configuration</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch03s07.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch04s02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;4.&nbsp;Configuration"><div class="titlepage"><div><div><h2 class="title"><a name="chapter-configuration"></a>Chapter&nbsp;4.&nbsp;Configuration</h2></div></div></div><div class="toc"><dl><dt><span class="sect1"><a href="ch04.html#servlet-configuration">4.1. Servlet Configuration</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch04.html#servlet-mapping">4.1.1. Servlet Mapping</a></span></dt><dt><span class="sect2"><a href="ch04.html#load-on-startup">4.1.2. Load On Startup</a></span></dt><dt><span class="sect2"><a href="ch04.html#type-converter-class">4.1.3. Type Converter Class</a></span></dt><dt><span class="sect2"><a href="ch04.html#config-service-class">4.1.4. Config Service Class</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch04s02.html">4.2. Application Configuration</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch04s02.html#click-app">4.2.1. Click App</a></span></dt><dt><span class="sect2"><a href="ch04s02.html#application-pages">4.2.2. Pages</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch04s02.html#application-multiple-packages">4.2.2.1. Multiple Pages Packages</a></span></dt></dl></dd><dt><span class="sect2"><a href="ch04s02.html#application-page">4.2.3. Page</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch04s02.html#application-automapping">4.2.3.1. Page Automapping</a></span></dt><dt><span class="sect3"><a href="ch04s02.html#application-excludes">4.2.3.2. Automapping Excludes</a></span></dt><dt><span class="sect3"><a href="ch04s02.html#application-autobinding">4.2.3.3. Page Autobinding</a></span></dt><dt><span class="sect3"><a href="ch04s02.html#application-autobinding-annotation">4.2.3.4. Page Autobinding - Using Annotations</a></span></dt></dl></dd><dt><span class="sect2"><a href="ch04s02.html#application-headers">4.2.4. Headers</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch04s02.html#browser-caching">4.2.4.1. Browser Caching</a></span></dt></dl></dd><dt><span class="sect2"><a href="ch04s02.html#application-format">4.2.5. Format</a></span></dt><dt><span class="sect2"><a href="ch04s02.html#application-mode">4.2.6. Mode</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch04s02.html#page-auto-loading">4.2.6.1. Page Auto Loading</a></span></dt><dt><span class="sect3"><a href="ch04s02.html#click-logging">4.2.6.2. Click and Velocity Logging</a></span></dt></dl></dd><dt><span class="sect2"><a href="ch04s02.html#application-controls">4.2.7. Controls</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch04s03.html">4.3. Auto Deployed Files</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch04s03.html#deploying-restricted-env">4.3.1. Deploying resources in a restricted environment</a></span></dt><dt><span class="sect2"><a href="ch04s03.html#deploying-custom-resources">4.3.2. Deploying Custom Resources</a></span></dt></dl></dd></dl></div><p>This section discusses how to setup and configure an Apache Click web
+  application.
+  </p><p>The Click configuration files include:
+  </p><div class="informaltable"><table style="border: none;"><colgroup><col><col></colgroup><tbody><tr><td style="border-right: 0.5pt solid ; ">
+            <span class="inlinemediaobject"><img src="images/configuration/config-files.png"></span>
+          </td><td style="">
+            <div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p> WEB-INF/
+                  <a class="link" href="ch04s02.html" title="4.2.&nbsp;Application Configuration">click.xml</a>
+                    &nbsp; - &nbsp; Application Configuration (
+                  <span class="bold"><strong>required</strong></span>)
+                </p></li><li class="listitem"><p> WEB-INF/
+                  <a class="link" href="ch04.html#servlet-configuration" title="4.1.&nbsp;Servlet Configuration">web.xml</a>
+                    &nbsp; - &nbsp; Servlet Configuration (
+                  <span class="bold"><strong>required</strong></span>)
+                </p></li></ul></div>
+          </td></tr></tbody></table></div><div class="sect1" title="4.1.&nbsp;Servlet Configuration"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="servlet-configuration"></a>4.1.&nbsp;Servlet Configuration</h2></div></div></div><p>For a Click web application to function the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/ClickServlet.html" target="_blank">ClickServlet</a>
+    must be configured in the web application's <code class="filename">/WEB-INF/web.xml</code>
+    file. A basic web application which maps all <code class="literal">*.htm</code> requests
+    to a ClickServlet is provided below.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;web-app&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-name&gt;</span>ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-name&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-class&gt;</span>org.apache.click.ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-class&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;load-on-startup&gt;</span>0<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/load-on-startup&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-mapping&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-name&gt;</span>ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-name&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;url-pattern&gt;</span>*.htm<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/url-pattern&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-mapping&gt;</span>
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/web-app&gt;</span></pre><div class="sect2" title="4.1.1.&nbsp;Servlet Mapping"><div class="titlepage"><div><div><h3 class="title"><a name="servlet-mapping"></a>4.1.1.&nbsp;Servlet Mapping</h3></div></div></div><p>By convention all Click page templates should have an .htm extension,
+      and the ClickServlet should be mapped to process all *.htm URL requests.
+      With this convention you have all the static HTML pages use an .html extension
+      and they will not be processed as Click pages.
+      </p></div><div class="sect2" title="4.1.2.&nbsp;Load On Startup"><div class="titlepage"><div><div><h3 class="title"><a name="load-on-startup"></a>4.1.2.&nbsp;Load On Startup</h3></div></div></div><p>Note you should always set <code class="literal">load-on-startup</code> element
+      to be 0 so the servlet is initialized when the server is started. This will
+      prevent any delay for the first client which uses the application.
+      </p><p>The <code class="classname">ClickServlet</code> performs as much work as possible
+      at startup to improve performance later on. The Click start up and caching
+      strategy is configured with the Click application mode element in the
+      "<code class="filename">click.xml</code>" config file, covered next.
+      </p></div><div class="sect2" title="4.1.3.&nbsp;Type Converter Class"><div class="titlepage"><div><div><h3 class="title"><a name="type-converter-class"></a>4.1.3.&nbsp;Type Converter Class</h3></div></div></div><p>The ClickServlet uses the OGNL library for type coercion when binding
+      request parameters to bindable fields. The default type converter class 
+      used is <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="click-api/org/apache/click/util/RequestTypeConverter.html" target="_blank">RequestTypeConverter</a>.
+      To specify your own type converter configure a <code class="literal">type-converter-class</code>
+      init parameter with the ClickServlet. For example:
+      </p><pre class="programlisting">
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-name&gt;</span>ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-name&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-class&gt;</span>org.apache.click.ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-class&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;load-on-startup&gt;</span>0<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/load-on-startup&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;init-param&gt;</span>
+	    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;param-name&gt;</span>type-converter-class<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/param-name&gt;</span>
+	    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;param-value&gt;</span>com.mycorp.util.CustomTypeConverter<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/param-value&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/init-param&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet&gt;</span></pre></div><div class="sect2" title="4.1.4.&nbsp;Config Service Class"><div class="titlepage"><div><div><h3 class="title"><a name="config-service-class"></a>4.1.4.&nbsp;Config Service Class</h3></div></div></div><p>Click uses a single application configuration service which is
+      instantiated by the ClickServlet at startup. This service defines the 
+      application configuration and is used by the ClickServlet to map requests
+      to pages amongst other things.
+      </p><p>Once the ConfigService has been initialized it is stored in the
+      ServletContext using the key  <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="click-api/org/apache/click/service/ConfigService.html" target="_blank">ConfigService</a>
+      The default ConfigService is <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="click-api/org/apache/click/service/XmlConfigService.html" target="_blank">XmlConfigService</a>,
+      which configuration is discussed in detail in the next section.
+ 	    </p><p>To use an alternative configuration service specify a
+      <code class="literal">config-service-class</code> context parameter. For example:
+ 	    </p><pre class="programlisting">
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;web-app</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">xmlns</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"http://java.sun.com/xml/ns/j2ee"</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">xmlns:xsi</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"http://www.w3.org/2001/XMLSchema-instance"</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">xsi:schemaLocation</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">version</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"2.4"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+
+ ...
+
+     <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;context-param&gt;</span>
+         <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;param-name&gt;</span>config-service-class<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/param-name&gt;</span>
+          <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;param-value&gt;</span>com.mycorp.service.CustomConfigSerivce<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/param-value&gt;</span>
+      <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/context-param&gt;</span>
+ 
+  ...
+ 
+ <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/web-app&gt;</span></pre></div></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch03s07.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch04s02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">3.7.&nbsp;Layouts&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;4.2.&nbsp;Application Configuration</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch04s02.html b/org.apache.click.eclipse/documentation/user-guide/ch04s02.html
new file mode 100644
index 0000000..803b813
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch04s02.html
@@ -0,0 +1,452 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>4.2.&nbsp;Application Configuration</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch04.html" title="Chapter&nbsp;4.&nbsp;Configuration"><link rel="prev" href="ch04.html" title="Chapter&nbsp;4.&nbsp;Configuration"><link rel="next" href="ch04s03.html" title="4.3.&nbsp;Auto Deployed Files"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">4.2.&nbsp;Application Configuration</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch04.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;4.&nbsp;Configuration</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch04s03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="4.2.&nbsp;Application Configuration"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="application-configuration"></a>4.2.&nbsp;Application Configuration</h2></div></div></div><p> The heart of a Click application is the <code class="filename">click.xml</code>
+    configuration file. This file specifies the application pages, headers, the
+    format object and the applications mode.
+    </p><p>By default the ClickServlet will attempt to load the application
+    configuration file using the path: &nbsp; <code class="filename">/WEB-INF/click.xml</code>
+    </p><p>If this file is not found under the <code class="literal">WEB-INF</code> directory,
+    then ClickServlet will attempt to load it from the classpath as
+    <code class="filename">/click.xml</code>.
+    </p><p>See <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-dtd.html" target="_blank">Click DTD</a> for the click-app
+    XML definition.
+    </p><p>A complete Click configuration example is available
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-dtd-example.html" target="_blank">here</a> which can be used as a quick
+    reference when configuring Click.
+    </p><p>A basic Click app config file is provided below:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">&lt;!-- Specify the Java package where Page classes can be found --&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.page"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;mode</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"profile"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>An advanced config file would look like this:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">charset</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"UTF-8"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">locale</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"de"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">&lt;!-- Specify the Java package where Page classes can be found --&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.banking.page"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;page</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">path</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"index.htm"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Home"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/pages&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">&lt;!-- Specify a second Java package where Page classes can be found --&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.common.page"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;format</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.util.Format"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;mode</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"profile"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;log-service</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"org.apache.click.extras.service.Log4JLogService"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>The take away point is that there is not much to configure, even for
+    advanced uses.
+    </p><div class="sect2" title="4.2.1.&nbsp;Click App"><div class="titlepage"><div><div><h3 class="title"><a name="click-app"></a>4.2.1.&nbsp;Click App</h3></div></div></div><p>The root <span class="symbol">click-app</span> element defines two application
+      localization attributes <code class="varname">charset</code> and <code class="varname">locale</code>.
+      </p><div class="literallayout"><p>&lt;!ELEMENT&nbsp;<span class="symbol">click-app</span>&nbsp;(pages*,&nbsp;headers?,&nbsp;format?,&nbsp;mode?,&nbsp;controls?,<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;file-upload-service?,&nbsp;log-service?,&nbsp;template-service?)&gt;<br>
+&nbsp;&nbsp;&lt;!ATTLIST&nbsp;click-app&nbsp;<code class="varname">charset</code>&nbsp;CDATA&nbsp;#IMPLIED&gt;<br>
+&nbsp;&nbsp;&lt;!ATTLIST&nbsp;click-app&nbsp;<code class="varname">locale</code>&nbsp;CDATA&nbsp;#IMPLIED&gt;</p></div><p>The <code class="varname">charset</code> attribute defines the character encoding
+      set for:
+      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>Velocity templates</p></li><li class="listitem"><p>HttpServletRequest character encoding</p></li><li class="listitem"><p>Page Content-Type charset, see Page
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#getContentType()" target="_blank">getContentType()</a>
+          </p></li></ul></div><p>The <code class="varname">locale</code> attribute defines the default application
+      Locale. If this value is defined it will override Locale returned by the request.
+      Please see the Context
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Context.html#getLocale()" target="_blank">getLocale()</a>
+      for details. For example the following configuration sets the application
+      character set to UTF-8 and the default Locale as German (de):
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">charset</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">" UTF-8"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">locale</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"de"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+  ..
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre></div><div class="sect2" title="4.2.2.&nbsp;Pages"><div class="titlepage"><div><div><h3 class="title"><a name="application-pages"></a>4.2.2.&nbsp;Pages</h3></div></div></div><p>The first child element of the click-app is the mandatory
+      <code class="literal">pages</code> element which defines the list of Click pages.
+      </p><div class="literallayout"><p>&lt;!ELEMENT&nbsp;<code class="varname">pages</code>&nbsp;(<span class="symbol">page</span>*)&gt;<br>
+&nbsp;&nbsp;&nbsp;&lt;!ATTLIST&nbsp;pages&nbsp;<code class="varname">package</code>&nbsp;CDATA&nbsp;#IMPLIED&gt;<br>
+&nbsp;&nbsp;&nbsp;&lt;!ATTLIST&nbsp;pages&nbsp;<code class="varname">automapping</code>&nbsp;(true|false)&nbsp;"true"&gt;<br>
+&nbsp;&nbsp;&nbsp;&lt;!ATTLIST&nbsp;pages&nbsp;<code class="varname">autobinding</code>&nbsp;(true|false)&nbsp;"true"&gt;</p></div><p>The pages element can specify a default <code class="varname">package</code> name
+      which is prepended to the classname of any pages defined.
+      </p><p>The pages element also defines the <code class="varname">automapping</code> and
+      <code class="varname">automapping</code> attributes which is discussed in the
+      <a class="link" href="ch04s02.html#application-automapping" title="4.2.3.1.&nbsp;Page Automapping">Page Automapping</a> and
+      <a class="link" href="ch04s02.html#application-autobinding" title="4.2.3.3.&nbsp;Page Autobinding">Page Autobinding</a> sections
+      respectively.
+      </p><div class="sect3" title="4.2.2.1.&nbsp;Multiple Pages Packages"><div class="titlepage"><div><div><h4 class="title"><a name="application-multiple-packages"></a>4.2.2.1.&nbsp;Multiple Pages Packages</h4></div></div></div><p>Click can support multiple pages elements to enable the automapping
+        of multiple packages.
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.banking.page"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.common.page"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>With multiple pages elements, pages are loaded in the order of the page
+            elements, with manual page elements being loaded before automapped pages.
+            Once a page template has been mapped to a Page class it will not be replaced
+            by a subsequent potential match. So pages elements at the top take priority
+            over lower pages elements.
+        </p></div></div><div class="sect2" title="4.2.3.&nbsp;Page"><div class="titlepage"><div><div><h3 class="title"><a name="application-page"></a>4.2.3.&nbsp;Page</h3></div></div></div><p>The page element defines the Click application pages.
+      </p><div class="literallayout"><p>&lt;!ELEMENT&nbsp;<span class="symbol">page</span>(<code class="varname">header</code>*)&gt;<br>
+&nbsp;&nbsp;&nbsp;&lt;!ATTLIST&nbsp;page&nbsp;<code class="varname">path</code>&nbsp;CDATA&nbsp;#REQUIRED&gt;<br>
+&nbsp;&nbsp;&nbsp;&lt;!ATTLIST&nbsp;page&nbsp;<code class="varname">classname</code>&nbsp;CDATA&nbsp;#REQUIRED&gt;</p></div><p>Each page <code class="varname">path</code> must be unique, as the Click
+      application maps HTTP requests to the page paths.
+      </p><p>The Click application will create a new Page instance for
+      the given request using the configured page <code class="varname">classname</code>.
+      All pages must subclass
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html" target="_blank">Page</a> and provide
+      a public no arguments constructor, so they can be instantiated.
+      </p><p>Pages can also define <code class="varname">header</code> values which are
+      discussed in the next topic.
+      </p><p>When the Click application starts up it will check all the page
+      definitions. If there is a critical configuration error the ClickSerlvet
+      will log an <code class="literal">ERROR</code> message and throw an
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/UnavailableException.html" target="_blank">UnavailableException</a>.
+      If this occurs the click application will be permanently unavailable until
+      the error is fixed and the web app is restarted.
+      </p><div class="sect3" title="4.2.3.1.&nbsp;Page Automapping"><div class="titlepage"><div><div><h4 class="title"><a name="application-automapping"></a>4.2.3.1.&nbsp;Page Automapping</h4></div></div></div><p> Page automapping will automatically configure application pages
+        using a simple set of rules. This enables you to greatly streamline your
+        configuration file as you only need to define pages which don't fit
+        the automapping rules.
+        </p><p>Automapping will attempt to associate each page template (*.htm)
+        and JSP file in the web application (excluding those under the WEB-INF
+        and click directories) to a Page class. Automapped pages are loaded after
+        the manually defined pages are loaded, and manually defined pages takes
+        preference. When automapping is enabled the Click application will log
+        the page mappings when in debug or trace mode.
+        </p><p>For example, given the following page path to class mapping:
+        </p><div class="literallayout"><p>index.htm&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;=&gt;&nbsp;<span class="token">com.mycorp.page.Home</span><br>
+search.htm&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;=&gt;&nbsp;<span class="token">com.mycorp.page.Search</span><br>
+contacts/contacts.htm&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;=&gt;&nbsp;<span class="token">com.mycorp.page.contacts.Contacts</span><br>
+security/login.htm&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;=&gt;&nbsp;<span class="token">com.mycorp.page.security.Login</span><br>
+security/logout.htm&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;=&gt;&nbsp;<span class="token">com.mycorp.page.security.Logout</span><br>
+security/change-password.htm&nbsp;&nbsp;=&gt;&nbsp;<span class="token">com.mycorp.page.security.ChangePassword</span></p></div><p>The above mapping could be configured manually by setting the
+        <span class="symbol">automapping</span> attribute to "false" and using the package
+        prefix, for example:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="token">com.mycorp.page</span>" <span class="symbol">automapping</span>="false"&gt;
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;page</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">path</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"index.htm"</span>                    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="token">Home</span>"/&gt;
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;page</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">path</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"search.htm"</span>                   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="token">Search</span>"/&gt;
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;page</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">path</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"contacts/contacts.htm"</span>        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="token">contacts.Contacts</span>"/&gt;
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;page</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">path</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"security/login.htm"</span>           <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="token">security.Login</span>"/&gt;
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;page</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">path</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"security/logout.htm"</span>          <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="token">security.Logout</span>"/&gt;
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;page</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">path</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"security/change-password.htm"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="token">security.ChangePassword</span>"/&gt;
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/pages&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>By using <span class="symbol">automapping</span> the page paths will automatically
+        map to page classes: (except for Home page which doesn't automatically map
+        to index.html)
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><span class="token">com.mycorp.page</span>" <span class="symbol">automapping</span>="true"&gt;
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;page</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">path</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"index.htm"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Home"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/pages&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>Note <span class="symbol">automapping</span> is true by default, so it could be
+        omitted from the configuration file.
+        </p><p>The page template name to classname convention is:
+        </p><div class="literallayout"><p>change-password.htm&nbsp;&nbsp;=&gt;&nbsp;&nbsp;<span class="token">ChangePassword</span><br>
+change_password.htm&nbsp;&nbsp;=&gt;&nbsp;&nbsp;<span class="token">ChangePassword</span><br>
+changePassword.htm&nbsp;&nbsp;&nbsp;=&gt;&nbsp;&nbsp;<span class="token">ChangePassword</span><br>
+ChangePassword.htm&nbsp;&nbsp;&nbsp;=&gt;&nbsp;&nbsp;<span class="token">ChangePassword</span></p></div><p>When automapping pages, if a class cannot be found Click will attempt
+        to add the 'Page' suffix to the classname if not already present and map
+        this. For example:
+        </p><div class="literallayout"><p>customer.htm&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;=&gt;&nbsp;&nbsp;<span class="token">CustomerPage</span><br>
+change-password.htm&nbsp;&nbsp;=&gt;&nbsp;&nbsp;<span class="token">ChangePasswordPage</span></p></div></div><div class="sect3" title="4.2.3.2.&nbsp;Automapping Excludes"><div class="titlepage"><div><div><h4 class="title"><a name="application-excludes"></a>4.2.3.2.&nbsp;Automapping Excludes</h4></div></div></div><p>With Page automapping there can be resources where you don't want
+        automapping applied. For example when using a JavaScript library with lots
+        of <code class="literal">.htm</code> files, you don't want automapping to try and
+        find Page class for each of these files. In these situations you can use
+        the pages <span class="symbol">excludes</span> element.
+        </p><div class="literallayout"><p>&lt;!ELEMENT&nbsp;<span class="symbol">excludes</span>&nbsp;(#PCDATA)&gt;<br>
+&nbsp;&nbsp;&nbsp;&lt;!ATTLIST&nbsp;excludes&nbsp;<code class="varname">pattern</code>&nbsp;CDATA&nbsp;#REQUIRED&gt;</p></div><p>For example if our application uses the TinyMCE JavaScript library
+        we could configure our pages automapping to exclude all <code class="literal">.htm</code>
+        files under the <code class="literal">/tiny_mce</code> directory.
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.page"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+    <span class="symbol">&lt;excludes</span> pattern="<code class="varname">/tiny_mce/*</code>"/&gt;
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/pages&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>The excludes pattern can specify multiple directories or files using a
+          comma separated notation. For example:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.page"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+    <span class="symbol">&lt;excludes</span> pattern="<code class="varname">/dhtml/*, /tiny_mce/*, banner.htm, about.htm</code>"/&gt;
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/pages&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>HTM files excluded from Page automapping are handled by an internal
+        Page class with caching headers enabled.
+        </p></div><div class="sect3" title="4.2.3.3.&nbsp;Page Autobinding"><div class="titlepage"><div><div><h4 class="title"><a name="application-autobinding"></a>4.2.3.3.&nbsp;Page Autobinding</h4></div></div></div><p>By default all pages have autobinding enabled. With autobinding
+        the ClickServlet will automatically:
+        </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p> add any public controls to the page, after the page constructor
+            has been invoked
+            </p></li><li class="listitem"><p> if the public control name is not defined, its name will be
+            set to the value of its field name
+            </p></li><li class="listitem"><p> bind any request parameters to public page fields, after page
+            constructor has been invoked. See
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/ClickServlet.html#processPageRequestParams(org.apache.click.Page)" target="_blank">ClickServlet.processPageRequestParams(Page)</a>
+            for more details
+            </p></li><li class="listitem"><p> add any public page fields to the page model (this step occurs
+            right before the page is rendered)</p></li></ul></div><p>For example:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> EmployeePage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> Form employeeForm = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Form();
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> Table myTable = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Table();
+
+}</pre><p>In the example above the <code class="varname">employeeForm</code> and
+        <code class="varname">myTable</code> controls were not added to the page. Also note
+        that Form and Table do not have their names defined.
+        </p><p>When autobinding is enabled, ClickServlet will create a new Page and
+        add the public controls to the page. In the example above the
+        <code class="varname">employeeForm</code> and <code class="varname">myTable</code> will be
+        added to the page, as if you had invoked,
+        <code class="methodname">addControl(employeeForm)</code> and
+        <code class="methodname">addControl(myTable)</code>.
+        </p><p>The control's names were not defined so ClickServlet will set their
+        names to the value of their field/variable name. In this case the Form
+        name will be set to <code class="varname">employeeForm</code> while the Table name
+        will set to <code class="varname">myTable</code>.
+        </p><p>The above example is thus a shorthand way of writing the following:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> EmployeePage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> Form employeeForm = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Form();
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> Table myTable = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Table();
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onInit() {
+        employeeForm.setName(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"employeeForm"</span>);
+        addControl(employeeForm);
+
+        myTable.setName(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"myTable"</span>);
+        addControl(myTable);
+    }
+}</pre><p>You can turn this behaviour off by setting the <span class="symbol">autobinding</span>
+        attribute to false, for example:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.page"</span> <span class="symbol">autobinding</span>="<code class="varname">false</code>"/&gt;
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre></div><div class="sect3" title="4.2.3.4.&nbsp;Page Autobinding - Using Annotations"><div class="titlepage"><div><div><h4 class="title"><a name="application-autobinding-annotation"></a>4.2.3.4.&nbsp;Page Autobinding - Using Annotations</h4></div></div></div><p>Click provides the
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/Bindable.html" target="_blank">Bindable</a>
+        annotation which enables autobinding of Page fields. The Bindable
+        annotation can bind private, protected and public Page fields.
+        However by default, Click's autobinding feature operates only on
+        <code class="literal">public</code> fields. The reason for this is keeping
+        backwards compatibility with earlier versions which did not support
+        the Bindable annotation.
+        </p><p>To enable Click to recognize the <span class="symbol">@Bindable</span>
+        annotation you need to set the <span class="symbol">autobinding</span>
+        attribute to <code class="varname">annotation</code>, for example:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.page"</span> <span class="symbol">autobinding</span>="<code class="varname">annotation</code>"/&gt;
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>You can now use the <span class="symbol">@Bindable</span> annotation in your
+        Pages:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> EmployeePage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span class="symbol">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> Form employeeForm = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Form();
+
+    <span class="symbol">@Bindable</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> Table myTable = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Table();
+
+}</pre></div></div><div class="sect2" title="4.2.4.&nbsp;Headers"><div class="titlepage"><div><div><h3 class="title"><a name="application-headers"></a>4.2.4.&nbsp;Headers</h3></div></div></div><p>The optional <code class="literal">headers</code> element defines a list of
+      <code class="literal">header</code> elements which are applied to all pages.
+      </p><div class="literallayout"><p>&lt;!ELEMENT&nbsp;<code class="varname">headers</code>&nbsp;(<span class="symbol">header</span>*)&gt;</p></div><p>The <span class="symbol">header</span> element defines header name and value
+      pairs which are applied to the
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpServletResponse.html" target="_blank">HttpServletResponse</a>.
+      </p><div class="literallayout"><p>&lt;!ELEMENT&nbsp;<span class="symbol">header</span>&nbsp;(#PCDATA)&gt;<br>
+&nbsp;&nbsp;&nbsp;&lt;!ATTLIST&nbsp;header&nbsp;<code class="varname">name</code>&nbsp;CDATA&nbsp;#REQUIRED&gt;<br>
+&nbsp;&nbsp;&nbsp;&lt;!ATTLIST&nbsp;header&nbsp;<code class="varname">value</code>&nbsp;CDATA&nbsp;#REQUIRED&gt;<br>
+&nbsp;&nbsp;&nbsp;&lt;!ATTLIST&nbsp;header&nbsp;<code class="varname">type</code>&nbsp;(String|Integer|Date)&nbsp;"String"&gt;</p></div><p>Page headers are set after the Page has been constructed and before
+      <code class="methodname">onInit()</code> is called. Pages can then modify their
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#headers" target="_blank">headers</a>
+      property using the
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#setHeader(java.lang.String,%20java.lang.Object)" target="_blank">setHeader()</a>
+      method.
+      </p><div class="sect3" title="4.2.4.1.&nbsp;Browser Caching"><div class="titlepage"><div><div><h4 class="title"><a name="browser-caching"></a>4.2.4.1.&nbsp;Browser Caching</h4></div></div></div><p>Headers are typically used to switch off browser caching. By
+        default Click will use the following no caching header values if you don't
+        define a <code class="literal">headers</code> element in your application:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages&gt;</span>
+     ..
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/pages&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;headers&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;header</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Pragma"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"no-cache"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;header</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Cache-Control"</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"no-store, no-cache, must-revalidate, post-check=0, pre-check=0"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;header</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Expires"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"1"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Date"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/headers&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>Alternatively you can define your headers individually in pages or
+        for all application pages by setting header values. For example to switch
+        off caching in the login page, note the value for a Date type should
+        be a long number value:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.page"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;page</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">path</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"login.htm"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Login"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;header</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Pragma"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"no-cache"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;header</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Expires"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"1"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Date"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/page&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/pages&gt;</span></pre><p>If you wanted to enable caching for a particular page you could set
+        the following page cache control header. This will mark the page as cachable
+        for a period of 1 hour after which it should be reloaded.
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.page"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;page</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">path</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"home.htm"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Home"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;header</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Cache-Control"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"max-age=3600, public, must-revalidate"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/page&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/pages&gt;</span></pre><p>To apply header values globally define header values in the headers
+        element. For example:
+        </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages&gt;</span>
+     ..
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/pages&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;headers&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;header</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Pragma"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"no-cache"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;header</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Cache-Control"</span>
+               <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"no-store, no-cache, must-revalidate, post-check=0, pre-check=0"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;header</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Expires"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">value</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"1"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Date"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/headers&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre></div></div><div class="sect2" title="4.2.5.&nbsp;Format"><div class="titlepage"><div><div><h3 class="title"><a name="application-format"></a>4.2.5.&nbsp;Format</h3></div></div></div><p>The optional <code class="literal">format</code> element defines the Format
+      object classname which is applied to all pages.
+      </p><div class="literallayout"><p>&lt;!ELEMENT&nbsp;<span class="symbol">format</span>&nbsp;(#PCDATA)&gt;<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&lt;ATTLIST&nbsp;format&nbsp;<code class="varname">classname</code>&nbsp;CDATA&nbsp;#FIXED&nbsp;"org.apache.click.util.Format"&gt;</p></div><p>By default all Click pages are configured with a
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/Format.html" target="_blank">org.apache.click.util.Format</a>
+      object. The format object is made available in the Velocity page templates
+      using the name <code class="varname">$format</code>.
+      </p><p>To specify a custom format class configure a <code class="literal">format</code>
+      element in the click-app descriptor. For example:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  ..
+  <span class="symbol">&lt;format</span> classname="<code class="varname">com.mycorp.util.CustomFormat</code>"/&gt;
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre></div><div class="sect2" title="4.2.6.&nbsp;Mode"><div class="titlepage"><div><div><h3 class="title"><a name="application-mode"></a>4.2.6.&nbsp;Mode</h3></div></div></div><p>The optional <code class="literal">mode</code> element defines the application
+      logging and caching mode.
+      </p><div class="literallayout"><p>&lt;!ELEMENT&nbsp;<span class="symbol">mode</span>&nbsp;(#PCDATA)&gt;<br>
+&nbsp;&nbsp;&nbsp;&nbsp;&lt;ATTLIST&nbsp;mode&nbsp;value&nbsp;(<code class="varname">production|profile|development|debug|trace</code>)&nbsp;"development"&gt;</p></div><p>By default Click applications run in <code class="literal">development</code> mode,
+      which switches off page template caching, and the logging level is set to
+      <code class="literal">INFO</code>.
+      </p><p>To change the default application mode configure a mode element in the
+      click-app descriptor. For example to specify <code class="literal">production</code>
+      mode you would add the following mode element:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  ..
+  <span class="symbol">&lt;mode</span> value="<code class="varname">production</code>"&gt;
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>The application mode configuration can be overridden by setting the
+      system property <code class="literal">"click.mode"</code>. This can be use in the scenario
+      of debugging a problem on a production system, where you change the mode to
+      <code class="literal">trace</code> by setting the following system property and
+      restarting the application.
+      </p><div class="literallayout"><p>-Dclick.mode=trace</p></div><p>The Click Application modes and their settings for Page auto loading,
+      template caching and logging levels are:
+      </p><div class="informaltable"><table style="border-collapse: collapse;border-top: 0.5pt solid ; border-bottom: 0.5pt solid ; border-left: 0.5pt solid ; border-right: 0.5pt solid ; "><colgroup><col><col><col><col><col></colgroup><thead><tr><th style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; ">
+                <p>
+                  Application mode
+                </p>
+              </th><th style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; ">
+                <p>
+                  Page auto loading
+                </p>
+              </th><th style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; ">
+                <p>
+                  Template caching
+                </p>
+              </th><th style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; ">
+                <p>
+                  Click log level
+                </p>
+              </th><th style="border-bottom: 0.5pt solid ; ">
+                <p>
+                  Velocity log level
+                </p>
+              </th></tr></thead><tbody><tr><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>
+                  <span class="bold"><strong>production</strong></span>
+                </p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>No</p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>Yes</p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>WARN</p>
+              </td><td style="border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>ERROR</p>
+              </td></tr><tr><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>
+                  <span class="bold"><strong>profile</strong></span>
+                </p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>No</p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>Yes</p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>INFO</p>
+              </td><td style="border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>ERROR</p>
+              </td></tr><tr><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>
+                  <span class="bold"><strong>development</strong></span>
+                </p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>Yes</p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>No</p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>INFO</p>
+              </td><td style="border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>ERROR</p>
+              </td></tr><tr><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>
+                  <span class="bold"><strong>debug</strong></span>
+                </p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>Yes</p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>No</p>
+              </td><td style="border-right: 0.5pt solid ; border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>DEBUG</p>
+              </td><td style="border-bottom: 0.5pt solid ; " align="center" valign="middle">
+                <p>ERROR</p>
+              </td></tr><tr><td style="border-right: 0.5pt solid ; " align="center" valign="middle">
+                <p>
+                  <span class="bold"><strong>trace</strong></span>
+                </p>
+              </td><td style="border-right: 0.5pt solid ; " align="center" valign="middle">
+                <p>Yes</p>
+              </td><td style="border-right: 0.5pt solid ; " align="center" valign="middle">
+                <p>No</p>
+              </td><td style="border-right: 0.5pt solid ; " align="center" valign="middle">
+                <p>TRACE</p>
+              </td><td style="" align="center" valign="middle">
+                <p>WARN</p>
+              </td></tr></tbody></table></div><div class="sect3" title="4.2.6.1.&nbsp;Page Auto Loading"><div class="titlepage"><div><div><h4 class="title"><a name="page-auto-loading"></a>4.2.6.1.&nbsp;Page Auto Loading</h4></div></div></div><p>When Page Auto Loading is enabled any new page templates and classes
+        will be automatically loaded at runtime. These pages are loaded using the
+        <a class="link" href="ch04s02.html#application-automapping" title="4.2.3.1.&nbsp;Page Automapping">Page Automapping</a> rules.
+        </p><p>Page auto loading is a very handy feature for rapid development as
+        you do not have to restart you application server to pick up new pages.
+        </p></div><div class="sect3" title="4.2.6.2.&nbsp;Click and Velocity Logging"><div class="titlepage"><div><div><h4 class="title"><a name="click-logging"></a>4.2.6.2.&nbsp;Click and Velocity Logging</h4></div></div></div><p>The Click and Velocity runtimes use
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/service/LogService.html" target="_blank">LogService</a>
+        for logging messages. The default LogService implementation is
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/service/ConsoleLogService.html" target="_blank">ConsoleLogService</a>
+        which will send messages to the console [System.out]. For example the
+        following logging output is for a HomePage request when the application
+        mode is <code class="literal">trace</code>:
+        </p><div class="literallayout"><p>[Click]&nbsp;[debug]&nbsp;GET&nbsp;http://localhost:8080/quickstart/home.htm<br>
+[Click]&nbsp;[trace]&nbsp;&nbsp;&nbsp;&nbsp;invoked:&nbsp;HomePage.&lt;&lt;init&gt;&gt;<br>
+[Click]&nbsp;[trace]&nbsp;&nbsp;&nbsp;&nbsp;invoked:&nbsp;HomePage.onSecurityCheck()&nbsp;:&nbsp;true<br>
+[Click]&nbsp;[trace]&nbsp;&nbsp;&nbsp;&nbsp;invoked:&nbsp;HomePage.onInit()<br>
+[Click]&nbsp;[trace]&nbsp;&nbsp;&nbsp;&nbsp;invoked:&nbsp;HomePage.onGet()<br>
+[Click]&nbsp;[trace]&nbsp;&nbsp;&nbsp;&nbsp;invoked:&nbsp;HomePage.onRender()<br>
+[Click]&nbsp;[info&nbsp;]&nbsp;&nbsp;&nbsp;&nbsp;renderTemplate:&nbsp;/home.htm&nbsp;-&nbsp;6&nbsp;ms<br>
+[Click]&nbsp;[trace]&nbsp;&nbsp;&nbsp;&nbsp;invoked:&nbsp;HomePage.onDestroy()<br>
+[Click]&nbsp;[info&nbsp;]&nbsp;handleRequest:&nbsp;&nbsp;/home.htm&nbsp;-&nbsp;24&nbsp;ms</p></div><p>Any unhandled <code class="literal">Throwable</code> errors are logged by the
+        ClickServlet.
+        </p><p>Note that Click Extras also provide log adaptors for
+        <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/service/Log4JLogService.html" target="_blank">Log4J</a>
+        and the <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/service/JdkLogService.html" target="_blank">JDK Logging API</a>.
+        </p><p>When an application is not in <code class="literal">production</code> mode the
+        error page displays detailed debugging information. When the application
+        mode is <code class="literal">production</code> no debug information is displayed to
+        prevent sensitive information being revealed. This behaviour can be changed
+        by modifying the deployed <code class="filename">click/error.htm</code> page template.
+        </p></div></div><div class="sect2" title="4.2.7.&nbsp;Controls"><div class="titlepage"><div><div><h3 class="title"><a name="application-controls"></a>4.2.7.&nbsp;Controls</h3></div></div></div><p>The optional <code class="literal">controls</code> element defines a list of
+      <code class="literal">control</code> elements which will be deployed on application
+      startup.
+      </p><div class="literallayout"><p>&lt;!ELEMENT&nbsp;<code class="varname">controls</code>&nbsp;(<span class="symbol">control</span>*)&gt;</p></div><p>The <span class="symbol">control</span> registers
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html" target="_blank">Control</a> classes
+      which will have their <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#onDeploy(javax.servlet.ServletContext)" target="_blank">onDeploy()</a>
+      method invoked when the click application starts.
+      </p><div class="literallayout"><p>&lt;!ELEMENT&nbsp;<span class="symbol">control</span>&nbsp;(#PCDATA)&gt;<br>
+&nbsp;&nbsp;&nbsp;&lt;!ATTLIST&nbsp;control&nbsp;<code class="varname">classname</code>&nbsp;CDATA&nbsp;#REQUIRED&gt;</p></div><p>For example to have a <code class="classname">CustomField</code> control
+      deploy its resources on application startup, you would add the following
+      elements to your <code class="filename">click.xml</code> file:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+   ..
+
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;controls&gt;</span>
+     <span class="symbol">&lt;control</span> classname="<code class="varname">com.mycorp.control.CustomField</code>"/&gt;
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/controls&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch04.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch04.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch04s03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;4.&nbsp;Configuration&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;4.3.&nbsp;Auto Deployed Files</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch04s03.html b/org.apache.click.eclipse/documentation/user-guide/ch04s03.html
new file mode 100644
index 0000000..2e5326c
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch04s03.html
@@ -0,0 +1,179 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>4.3.&nbsp;Auto Deployed Files</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch04.html" title="Chapter&nbsp;4.&nbsp;Configuration"><link rel="prev" href="ch04s02.html" title="4.2.&nbsp;Application Configuration"><link rel="next" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Best Practices"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">4.3.&nbsp;Auto Deployed Files</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch04s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;4.&nbsp;Configuration</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch05.html">Next</a></td></tr></table><hr></div><div class="sect1" title="4.3.&nbsp;Auto Deployed Files"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="auto-deployed-files"></a>4.3.&nbsp;Auto Deployed Files</h2></div></div></div><p>To make pre-configured resources (templates, stylesheets, etc.)
+    available to web applications, Click automatically deploys configured
+    classpath resources to the <code class="varname">/click</code> directory at startup
+    (if not already present).
+    </p><p>You can modify these support files and Click will
+    <span class="bold"><strong>not</strong></span> overwrite them. These files include:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p> click/error.htm &nbsp; - &nbsp; the Page
+          <a class="link" href="ch02s09.html" title="2.9.&nbsp;Error Handling">Error Handling</a> template
+        </p></li><li class="listitem"><p> click/control.css &nbsp; - &nbsp; the Controls cascading stylesheet</p></li><li class="listitem"><p> click/control.js &nbsp; - &nbsp; the Controls JavaScript library</p></li><li class="listitem"><p> click/not-found.htm &nbsp; - &nbsp; the
+          <a class="link" href="ch02s10.html" title="2.10.&nbsp;Page Not Found">Page Not Found</a> template
+        </p></li></ul></div><p>For example to customize the control styles you can place a customized
+    copy (or even a brand new version) of <code class="filename">control.css</code> under
+    the <code class="varname">/click</code> folder in your web project:
+    </p><div class="literallayout"><p>/webapp/click/control.css</p></div><p>When Click starts up it will <span class="bold"><strong>not</strong></span>
+    override your copy of <code class="filename">control.css</code> with its own default
+    version.
+    </p><p>Different controls might deploy different stylesheet, javascript or image
+    files, however the above principle still applies. By placing a customized copy
+    of the stylesheet, javascript or image under the <code class="varname">/click</code> folder,
+    you will override the default resource.
+    </p><p>Be aware that some of the more complex controls (checklist, colorpicker,
+    tree), deploys resources to subfolders under <code class="varname">/click</code>, for
+    example <code class="literal">/click/checklist/*</code>.
+    </p><p>A control's Javadoc will normally indicate what resources are deployed
+    for that control.
+    </p><div class="sect2" title="4.3.1.&nbsp;Deploying resources in a restricted environment"><div class="titlepage"><div><div><h3 class="title"><a name="deploying-restricted-env"></a>4.3.1.&nbsp;Deploying resources in a restricted environment</h3></div></div></div><p>Some environments place restrictions on the file system and
+      Click won't be able to deploy its resources. WebLogic and
+      Google App Engine are examples of such environments. (Note that WebLogic has
+      a property to allow access to the file system. From the Admin Console go
+      to the <span class="emphasis"><em>Server node &gt; Web Applications</em></span>
+      tab and check the <span class="emphasis"><em>Archived Real Path Enabled</em></span> parameter.)
+      </p><p>If Click cannot deploy its resources because of limited file system
+      access or permissions, warning messages will be logged.
+      </p><p><span class="bold"><strong>Note: </strong></span>if your application is
+      running on a <span class="emphasis"><em>Servlet 3.0</em></span> compliant server, there is
+      no need to deploy resources. Servlet 3.0 specifies that if the server
+      cannot find a resource in the root directory of the webapp, it will look
+      for the resource under <span class="emphasis"><em>'META-INF/resources'</em></span>, and if
+      found, serve it up. Click is Servlet 3.0 compliant and packages its
+      resources under <span class="emphasis"><em>'META-INF/resources'</em></span>.
+      </p><p>Click provides a number of options to make resources available
+      in restricted environments which is covered below:
+      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>The first option (which will work in all environments) is to deploy
+          the resources at build time. Click ships with an Ant Task
+          called DeployTask that deploys Click static resources to a web
+          application. With this option Click's static resources can be copied
+          to the root directory of your webapp, where you can customize the
+          resources further if needed. The DeployTask can easily be incorporated
+          into your build script.
+          </p><p>Currently the DeployTask is part of the <code class="filename">click-dev-tools-xxx.jar</code>
+          that can be found in your Click distribution under the <span class="emphasis"><em>lib</em></span>
+          folder.
+          </p><p>Here is a basic example:
+          </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;target</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"deploy"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">description</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Deploy static resources"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;taskdef</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"deploy"</span>
+             <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"org.apache.click.tools.deploy.DeployTask"</span>
+             <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classpath</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"&lt;click-distribution&gt;/lib/click-dev-tasks-1.1.jar"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span> <a class="co" name="co-click-distribution" href="ch04s03.html#ca-click-distribution"><img src="images/callouts/1.gif" alt="1" border="0"></a>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;deploy</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">dir</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"&lt;webapp-root&gt;/WEB-INF"</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">todir</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"&lt;webapp-root&gt;"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span> <a class="co" name="co-webapp-root" href="ch04s03.html#ca-webapp-root"><img src="images/callouts/2.gif" alt="2" border="0"></a>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/target&gt;</span> </pre><div class="calloutlist"><table border="0" summary="Callout list"><tr xmlns:fo="http://www.w3.org/1999/XSL/Format"><td valign="top" align="left"><a name="ca-click-distribution"></a><a href="#co-click-distribution"><img src="images/callouts/1.gif" alt="1" border="0"></a> </td><td valign="top" align="left"><p><code class="literal">&lt;click-distribution&gt;</code> is the location
+              where Click is installed on your machine, for example:
+              <code class="literal">C:\software\click-2.1.0\</code>.
+              </p></td></tr><tr xmlns:fo="http://www.w3.org/1999/XSL/Format"><td valign="top" align="left"><a name="ca-webapp-root"></a><a href="#co-webapp-root"><img src="images/callouts/2.gif" alt="2" border="0"></a> </td><td valign="top" align="left"><p><code class="literal">&lt;webapp-root&gt;</code> is the root directory
+              of your webapp, for example: <code class="literal">C:\dev\my-webapp\</code>.
+              </p></td></tr></table></div><p>We use the <span class="emphasis"><em>&lt;deploy&gt;</em></span> Ant Task and specify
+          the attributes <code class="varname">dir</code> and <code class="varname">todir</code>.
+          </p><p><code class="varname">dir</code> specifies the <span class="emphasis"><em>source</em></span>
+          directory to scan for JARs and folders containing static resources,
+          while <code class="varname">todir</code> specifies the <span class="emphasis"><em>target</em></span>
+          directory where the resources should be copied to.
+          </p><p><code class="varname">dir</code> should point to your web application's
+          <span class="emphasis"><em>WEB-INF</em></span> folder, since that is where Click's JARs
+          will be located. <code class="varname">todir</code> should point to your web
+          application's root directory, since that is where Click's resources
+          will be served from.
+          </p><p>The DeployTask also supports nested
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://ant.apache.org/manual/CoreTypes/fileset.html" target="_blank">FileSets</a>
+          if you need to deploy resources from multiple source locations. For
+          example:</p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;target</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"deploy"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">description</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Deploy static resources"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;taskdef</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"deploy"</span>
+             <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"org.apache.click.tools.deploy.DeployTask"</span>
+             <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classpath</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"&lt;click-distribution&gt;/lib/click-dev-tasks-1.1.jar"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;deploy</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">todir</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"${dir.webapp}"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;fileset</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">dir</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"&lt;webapp-root&gt;/WEB-INF"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;include</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"**/classes"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;include</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"**/*.jar"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/fileset&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;fileset</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">dir</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"/some/folder/with/jars"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;include</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"lib-with-resources.jar"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;include</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"another-lib-with-resources.jar"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/fileset&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/deploy&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/target&gt;</span> </pre><p>The DeployTask also generates an HTML report in the same folder
+          where the build script is executed from. The report will indicate
+          which resources was deployed successfully and which resources
+          in your webapp root directory is outdated. (An outdated resource means
+          that the resource in the <span class="emphasis"><em>click-xxx.jar</em></span> differs
+          from the resource currently present in your webapp root directory.
+          This can happen when upgrading to a new version of Click)
+          </p></li><li class="listitem"><p>Another option is to add a mapping in <span class="emphasis"><em>web.xml</em></span>
+          to inform ClickServlet to serve static resources. This feature is made
+          available through the
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/service/ResourceService.html" target="_blank">ResourceService</a>
+          interface and its default implementation,
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/service/ClickResourceService.html" target="_blank">ClickResourceService</a>.
+          Below is an example:
+          </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-name&gt;</span>ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-name&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-class&gt;</span>org.apache.click.ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-class&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;load-on-startup&gt;</span>0<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/load-on-startup&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet&gt;</span>
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-mapping&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-name&gt;</span>ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-name&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;url-pattern&gt;</span>*.htm<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/url-pattern&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-mapping&gt;</span>
+
+ <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">&lt;!-- Inform ClickServlet to serve static resources contained under the /click/*
+       directory directly from Click's JAR files. --&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-mapping&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;servlet-name&gt;</span>ClickServlet<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-name&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;url-pattern&gt;</span>/click/*<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/url-pattern&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/servlet-mapping&gt;</span></pre><p>With this setup, ClickServlet will serve all static
+          <code class="varname">/click/*</code> resources directly from Click's JAR files.
+          </p><p>One restriction of ClickResourceService is it only serves
+          resources from the <span class="emphasis"><em>/click/*</em></span> folder. So if you use
+          third-party Click libraries that serve their resources from a different
+          folder e.g. <span class="emphasis"><em>/clickclick/*</em></span>, this option won't work
+          out-of-the-box.
+          </p><p>Also note that with this option Click's resources are served
+          directly from the JAR files, you won't be able to customize the resources,
+          if for example you want change the default styling through CSS.
+          </p></li><li class="listitem"><p>Another option is to manually deploy the resources. Click
+          resources are packaged in JARs under the directory
+          <span class="emphasis"><em>META-INF/resources</em></span>. You can use your IDE
+          to navigate into the JARs and copy all the resources from
+          <span class="emphasis"><em>META-INF/resources</em></span> to your webapp root directory.
+          </p><p>For example, to deploy the resources from
+          <span class="emphasis"><em>click-core.jar</em></span>, copy the <span class="emphasis"><em>/click</em></span>
+          folder and its contents to your web application root folder.
+          </p></li><li class="listitem"><p>And finally you can access Click's resources by deploying your
+          application on a development machine where there are no file system
+          restrictions and the WAR/EAR can be unpacked. You can then copy the
+          deployed resources to your webapp root directory.
+          </p></li></ul></div></div><div class="sect2" title="4.3.2.&nbsp;Deploying Custom Resources"><div class="titlepage"><div><div><h3 class="title"><a name="deploying-custom-resources"></a>4.3.2.&nbsp;Deploying Custom Resources</h3></div></div></div><p> Click supports two ways of deploying pre-configured resources
+      (templates, stylesheets, JavaScript etc.) from a Jar to a web application.
+      (This assumes that the environment Click is running in supports having
+      write access to the file system and that the WAR is unpacked.)
+      </p><div class="orderedlist"><ol class="orderedlist" type="1"><li class="listitem"><p> Through a Control's
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Control.html#onDeploy(javax.servlet.ServletContext)" target="_blank">onDeploy()</a>
+          event handler. See the <a class="link" href="ch04s02.html#application-controls" title="4.2.7.&nbsp;Controls">Controls</a>
+          section above.
+          </p></li><li class="listitem"><p>By packaging the resources (stylesheets, JavaScript, Images etc.)
+          into a special folder called <span class="emphasis"><em>'META-INF/resources'</em></span>.
+          </p></li></ol></div><p>As option #1 was already discussed above in section
+      <a class="link" href="ch04s02.html#application-controls" title="4.2.7.&nbsp;Controls">Controls</a>, lets look at option #2.
+      </p><p>When Click starts up, it scans each Jar and folder on the classpath
+      for specially marked entries starting with 'META-INF/resources/'. (Please
+      note that even though Click will scan the entire classpath it is strongly
+      recommended to host your Jar files under your WAR lib folder e.g. WEB-INF/lib.
+      Sharing Jars on the classpath can lead to class loading issues.)
+      </p><p>Click will then copy all files found under 'META-INF/resources/' to
+      the root directory of the webapp.
+      </p><p>
+      For example, given a Jar file with the following entries:
+      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>META-INF/resources/mycorp/edit_customer.js</p></li><li class="listitem"><p>META-INF/resources/mycorp/edit_customer.css</p></li><li class="listitem"><p>mycorp/pages/EditCustomerPage.class</p></li></ul></div><p>Click will copy the files <span class="emphasis"><em>'/mycorp/edit_customer.js'</em></span>
+      and <span class="emphasis"><em>'/mycorp/edit_customer.css'</em></span> to the web application
+      folder.
+      </p><p>Thus if the web application is called 'webapp', the files will be
+      deployed as <span class="emphasis"><em>'webapp/mycorp/edit_customer.js'</em></span> and
+      <span class="emphasis"><em>'webapp/mycorp/edit_customer.css'</em></span>.
+      </p><p>Option #2 is the recommended approach for deploying your own
+      resources since it makes the managing and maintenance of resources much
+      easier.
+      </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch04s02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch04.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch05.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">4.2.&nbsp;Application Configuration&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;5.&nbsp;Best Practices</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch05.html b/org.apache.click.eclipse/documentation/user-guide/ch05.html
new file mode 100644
index 0000000..575ab87
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch05.html
@@ -0,0 +1,197 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>Chapter&nbsp;5.&nbsp;Best Practices</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="index.html" title="Apache Click"><link rel="prev" href="ch04s03.html" title="4.3.&nbsp;Auto Deployed Files"><link rel="next" href="ch05s02.html" title="5.2.&nbsp;Packages and Classes"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Chapter&nbsp;5.&nbsp;Best Practices</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch04s03.html">Prev</a>&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch05s02.html">Next</a></td></tr></table><hr></div><div class="chapter" title="Chapter&nbsp;5.&nbsp;Best Practices"><div class="titlepage"><div><div><h2 class="title"><a name="chapter-best-practices"></a>Chapter&nbsp;5.&nbsp;Best Practices</h2></div></div></div><div class="toc"><dl><dt><span class="sect1"><a href="ch05.html#security">5.1. Security</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch05.html#declarative-security">5.1.1. Declarative Security</a></span></dt><dt><span class="sect2"><a href="ch05.html#alternatve-security-solutions">5.1.2. Alternative Security solutions</a></span></dt><dt><span class="sect2"><a href="ch05.html#resources">5.1.3. Resources</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch05s02.html">5.2. Packages and Classes</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch05s02.html#page-classes">5.2.1. Page Classes</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch05s03.html">5.3. Page Auto Mapping</a></span></dt><dt><span class="sect1"><a href="ch05s04.html">5.4. Navigation</a></span></dt><dt><span class="sect1"><a href="ch05s05.html">5.5. Templating</a></span></dt><dt><span class="sect1"><a href="ch05s06.html">5.6. Menus</a></span></dt><dt><span class="sect1"><a href="ch05s07.html">5.7. Logging</a></span></dt><dt><span class="sect1"><a href="ch05s08.html">5.8. Error Handling</a></span></dt><dt><span class="sect1"><a href="ch05s09.html">5.9. Performance</a></span></dt></dl></div><p>This chapter discusses Best Practices for designing and building Apache
+  Click applications.
+  </p><div class="sect1" title="5.1.&nbsp;Security"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="security"></a>5.1.&nbsp;Security</h2></div></div></div><p>For application security it is highly recommended that you use the
+    declarative JEE Servlet path role based security model. While Click pages
+    provide an <code class="methodname">onSecurityCheck()</code> method for rolling your own
+    programatic security model, the declarative JEE model provides numerous
+    advantages.
+    </p><p>These advantages include:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p> Its an industry standard pattern making development and maintenance
+          easier.
+        </p></li><li class="listitem"><p> Application servers generally provide numerous ways of integration
+          with an organisations security infrastructure, including LDAP directories
+          and relational databases.
+        </p></li><li class="listitem"><p> Servlet security model support users bookmarking pages. When users
+          go to access these pages later, the container will automatically authenticate
+          them before allowing them to access the resource.
+        </p></li><li class="listitem"><p> Using this security model you can keep your Page code free of
+          security concerns. This makes you code more reusable, or at least easier
+          to write.
+        </p></li></ul></div><p>If your application has very fine grained or complex security requirements
+    you may need to combine both the JEE declarative security model and a
+    programmatic security model to meet your needs. In these cases its
+    recommended you use declarative security for course grained access and
+    programmatic security for finner grained access control.
+    </p><div class="sect2" title="5.1.1.&nbsp;Declarative Security"><div class="titlepage"><div><div><h3 class="title"><a name="declarative-security"></a>5.1.1.&nbsp;Declarative Security</h3></div></div></div><p> The declarative JEE Servlet security model requires users to be
+      authenticated and in the right roles before they can access secure resources.
+      Relative to many of the JEE specifications the Servlet security model is
+      surprisingly simple.
+      </p><p>
+      For example to secure admin pages, you add a security
+      constraint in your <code class="filename">web.xml</code> file. This requires users
+      to be in the <code class="varname">admin</code> role before they can access to any
+      resources under the <span class="symbol">admin</span> directory:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;security-constraint&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;web-resource-collection&gt;</span>
+      <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;web-resource-name&gt;</span>admin<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/web-resource-name&gt;</span>
+      <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;url-pattern&gt;</span><span class="symbol">/admin/*</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/url-pattern&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/web-resource-collection&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;auth-constraint&gt;</span>
+      <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;role-name&gt;</span><code class="varname">admin</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/role-name&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/auth-constraint&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/security-constraint&gt;</span></pre><p>The application user roles are defined in the <code class="filename">web.xml</code>
+      file as <code class="literal">security-role</code> elements:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;security-role&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;role-name&gt;</span><code class="varname">admin</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/role-name&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/security-role&gt;</span></pre><p>The Servlet security model supports three different authentication method:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+            <code class="literal">BASIC</code>  - only recommended for internal
+              applications where security is not important. This is the easiest
+              authentication method, which simply displays a dialog box to users
+              requiring them to authenticate before accessing secure resources.
+              The BASIC method is relatively unsecure as the username and password
+              are posted to the server as a Base64 encoded string.
+          </p></li><li class="listitem"><p>
+            <code class="literal">DIGEST</code>  - recommended for internal applications
+              with a moderate level of security. As with BASIC authentication,
+              this method simply displays a dialog box to users requiring them to
+              authenticate before accessing secure resources. Not all application
+              servers support DIGEST authentication, with only more recent
+              versions of Apache Tomcat supporting this method.
+          </p></li><li class="listitem"><p>
+            <code class="literal">FORM</code>  - recommended applications for where
+              you need a customised login page. For applications requiring a high
+              level of security it is recommended that you use the FORM method
+              over HTTPS.
+          </p></li></ul></div><p>The authentication method is specified in the &lt;login-method&gt; element.
+      For example to use the BASIC authentication method you would specify:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;login-config&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;auth-method&gt;</span><code class="varname">BASIC</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/auth-method&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;realm-name&gt;</span>Admin Realm<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/realm-name&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/login-config&gt;</span></pre><p>To use the FORM method you also need to specify the path to the login
+      page and the login error page:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;login-config&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;auth-method&gt;</span><code class="varname">FORM</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/auth-method&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;realm-name&gt;</span>Secure Realm<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/realm-name&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;form-login-config&gt;</span>
+      <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;form-login-page&gt;</span><span class="symbol">/login.htm</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/form-login-page&gt;</span>
+      <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;form-error-page&gt;</span><span class="symbol">/login.htm?auth-error=true</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/form-error-page&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/form-login-config&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/login-config&gt;</span></pre><p>In your Click <code class="filename">login.htm</code> page you need to include a
+      special <code class="varname">j_security_check</code> form which includes the input
+      fields <code class="varname">j_username</code> and <code class="varname">j_password</code>.
+      For example:
+      </p><pre class="programlisting"><span class="command"><strong>#if</strong></span> ($request.getParameter("<span class="symbol">auth-error</span>"))
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;div</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">style</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"margin-bottom:1em;margin-top:1em;color:red;"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+  Invalid User Name or Password, please try again.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;br/&gt;</span>
+  Please ensure Caps Lock is off.
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/div&gt;</span>
+<span class="command"><strong>#end</strong></span>
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;form</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">method</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"POST"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">action</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><code class="varname">j_security_check</code>" name="form"&gt;
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;table</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">border</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"0"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">style</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"margin-left:0.25em;"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+ <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;tr&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;td&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;label&gt;</span>User Name<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/label&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;font</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">color</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"red"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>*<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/font&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/td&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;td&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;input</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><code class="varname">j_username</code>" maxlength="20" style="width:150px;"/&gt;<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/td&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;td&gt;</span>&amp;nbsp;<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/td&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/tr&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;tr&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;td&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;label&gt;</span>User Password<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/label&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;font</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">color</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"red"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>*<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/font&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/td&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;td&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;input</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"password"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">name</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"</span><code class="varname">j_password</code>" maxlength="20" style="width:150px;"/&gt;<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/td&gt;</span>
+   <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;td&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;input</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"image"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">src</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"$context/images/login.png"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">title</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Click to Login"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/td&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/tr&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/table&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/form&gt;</span>
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;script</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/javascript"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span>
+  document.form.j_username.focus();
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/script&gt;</span></pre><p>When using FORM based authentication do <span class="bold"><strong>NOT</strong></span>
+      put application logic in a Click Login Page class, as the role of this page
+      is to simply render the login form. If you attempt to put navigation logic
+      in your Login Page class, the JEE Container may simply ignore it or throw
+      errors.
+      </p><p>Putting this all together below is a <code class="filename">web.xml</code>
+      snippet which features security constraints for pages under the admin
+      path and the user path. This configuration uses the FORM method for
+      authentication, and will also redirect unauthorized (403) requests to the
+      <code class="filename">/not-authorized.htm</code> page.
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;web-app&gt;</span>
+
+    ..
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;error-page&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;error-code&gt;</span>403<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/error-code&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;location&gt;</span><code class="varname">/not-authorized.htm</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/location&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/error-page&gt;</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;security-constraint&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;web-resource-collection&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;web-resource-name&gt;</span>admin<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/web-resource-name&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;url-pattern&gt;</span><code class="varname">/admin/*</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/url-pattern&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/web-resource-collection&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;auth-constraint&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;role-name&gt;</span><span class="symbol">admin</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/role-name&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/auth-constraint&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/security-constraint&gt;</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;security-constraint&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;web-resource-collection&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;web-resource-name&gt;</span>user<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/web-resource-name&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;url-pattern&gt;</span><code class="varname">/user/*</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/url-pattern&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/web-resource-collection&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;auth-constraint&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;role-name&gt;</span><span class="symbol">admin</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/role-name&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;role-name&gt;</span><span class="symbol">user</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/role-name&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/auth-constraint&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/security-constraint&gt;</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;login-config&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;auth-method&gt;</span><code class="varname">FORM</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/auth-method&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;realm-name&gt;</span>Secure Zone<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/realm-name&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;form-login-config&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;form-login-page&gt;</span><code class="varname">/login.htm</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/form-login-page&gt;</span>
+            <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;form-error-page&gt;</span><code class="varname">/login.htm?auth-error=true</code><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/form-error-page&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/form-login-config&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/login-config&gt;</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;security-role&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;role-name&gt;</span><span class="symbol">admin</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/role-name&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/security-role&gt;</span>
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;security-role&gt;</span>
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;role-name&gt;</span><span class="symbol">user</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/role-name&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/security-role&gt;</span>
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/web-app&gt;</span></pre></div><div class="sect2" title="5.1.2.&nbsp;Alternative Security solutions"><div class="titlepage"><div><div><h3 class="title"><a name="alternatve-security-solutions"></a>5.1.2.&nbsp;Alternative Security solutions</h3></div></div></div><p> There are also alternative security solutions that provide extra
+      features not available in JEE, such as RememberMe functionality, better
+      resource mapping and <code class="literal">Post Logon Page</code> support.
+      (<code class="literal">Post Logon Page</code> support allows one to specify a default
+      URL where the user will be forwarded after successful login. This feature
+      allows one to embed a login form in all non-secure pages and after successful
+      authentication the user will be forwarded to their home page.)
+      </p><p>Below are some of the alternative security solutions available:
+      </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://static.springframework.org/spring-security/site/index.html" target="_blank">Spring Security</a>
+          </p></li><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://securityfilter.sourceforge.net/" target="_blank">SecurityFilter</a>
+          </p></li><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://www.jsecurity.org/" target="_blank">JSecurity</a>
+          </p></li></ul></div></div><div class="sect2" title="5.1.3.&nbsp;Resources"><div class="titlepage"><div><div><h3 class="title"><a name="resources"></a>5.1.3.&nbsp;Resources</h3></div></div></div><p>For more information on using security see the resources below:</p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://stc.cis.brown.edu/~stc/Projects/Shibboleth/Version-3/Checklist/Tomcat-Authn/FormBasedAuthentication.pdf" target="_blank">
+                  Form Based Authentication
+            </a>  by Louis E. Mauget
+          </p></li><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/download.html" target="_blank">Servlet Specification</a>
+              by Sun Microsystems
+          </p></li><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://en.wikipedia.org/wiki/Basic_authentication_scheme" target="_blank">
+                    Basic authentication scheme
+            </a>
+          </p></li><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://en.wikipedia.org/wiki/Digest_access_authentication" target="_blank">
+                    Digest authentication scheme
+            </a>
+          </p></li><li class="listitem"><p>
+            <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://en.wikipedia.org/wiki/Https" target="_blank">Https URI scheme</a>
+          </p></li></ul></div></div></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch04s03.html">Prev</a>&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch05s02.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">4.3.&nbsp;Auto Deployed Files&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;5.2.&nbsp;Packages and Classes</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch05s02.html b/org.apache.click.eclipse/documentation/user-guide/ch05s02.html
new file mode 100644
index 0000000..9beed5b
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch05s02.html
@@ -0,0 +1,107 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>5.2.&nbsp;Packages and Classes</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Best Practices"><link rel="prev" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Best Practices"><link rel="next" href="ch05s03.html" title="5.3.&nbsp;Page Auto Mapping"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">5.2.&nbsp;Packages and Classes</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch05.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;5.&nbsp;Best Practices</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch05s03.html">Next</a></td></tr></table><hr></div><div class="sect1" title="5.2.&nbsp;Packages and Classes"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="packages-classes"></a>5.2.&nbsp;Packages and Classes</h2></div></div></div><p> An excellent way to design your project package structure is to
+    classify packages initially by technology. So in a Click application all
+    of our pages would be contained under a <span class="package">page</span> package.
+    This also works very well with the Page automapping feature.
+    </p><p>
+    All the projects domain entity classes would be contained under a
+    <span class="package">entity</span> package, and service classes would be contained
+    under a <span class="package">service</span> directory. Note alternative names for the
+    <span class="package">entity</span> package include domain or model. We also typically
+    have a <span class="package">util</span> package for any stray classes which don't quite
+    fit into the other packages.
+    </p><p>In Java, package names are singular by convention, so we have a util
+    package rather than a utils package.
+    </p><p>An example project structure for a MyCorp web application is illustrated
+    below:
+    </p><div class="figure"><a name="example-project-structure"></a><div class="figure-contents"><span class="inlinemediaobject"><img src="images/best-practices/packages-classes.png" alt="Example project structure"></span></div><p xmlns:fo="http://www.w3.org/1999/XSL/Format" class="title"><i>Figure&nbsp;5.1.&nbsp;Example project structure</i></p></div><br class="figure-break"><p>In this example application we use declarative role and path based security.
+    All the pages in the <span class="package">admin</span> package and directory require the
+    <code class="literal">"admin"</code> role to be access, while all the pages in the
+    <span class="package">user</span> package and directory require the <code class="literal">"user"</code>
+    role to be accessed.
+    </p><div class="sect2" title="5.2.1.&nbsp;Page Classes"><div class="titlepage"><div><div><h3 class="title"><a name="page-classes"></a>5.2.1.&nbsp;Page Classes</h3></div></div></div><p>A best practice when developing application Page classes is to
+      place common methods in a base page class. This is typically used for
+      providing access methods to application services and logger objects.
+      </p><p>For example the BasePage below provides access to Spring configured
+      service objects and a Log4J logger object:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> BasePage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">implements</span> ApplicationContextAware {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/** The Spring application context. */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> ApplicationContext applicationContext;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/** The page Logger instance. */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> Logger logger;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * Return the Spring configured Customer service.
+     *
+     * @return the Spring configured Customer service
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> CustomerService getCustomerService() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> (CustomerService) getBean(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"customerService"</span>);
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * Return the Spring configured User service.
+     *
+     * @return the Spring configured User service
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> UserService getUserService() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> (UserService) getBean(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"userService"</span>);
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * Return the page Logger instance.
+     *
+     * @return the page Logger instance
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> Logger getLogger() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (logger == null) {
+            logger = Logger.getLogger(getClass());
+        }
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> logger;
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see ApplicationContextAware#setApplicationContext(ApplicationContext)
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> setApplicationContext(ApplicationContext applicationContext)  {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">this</span>.applicationContext = applicationContext;
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * Return the configured Spring Bean for the given name.
+     *
+     * @param beanName the configured name of the Java Bean
+     * @return the configured Spring Bean for the given name
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> Object getBean(String beanName) {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> applicationContext.getBean(beanName);
+    }
+
+}</pre><p>Applications typically use a border template and have a
+      <code class="classname">BorderPage</code> which extends <code class="classname">BasePage</code>
+      and defines the template. For example:
+      </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> BorderPage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> BasePage {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/** The root Menu item. */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> Menu rootMenu = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Menu();
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">/**
+     * @see Page#getTemplate()
+     */</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> String getTemplate() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/border-template.htm"</span>;
+    }
+}</pre><p>Most application pages subclass <code class="classname">BorderPage</code>, except
+      AJAX pages which have no need for a HTML border template and typically extend
+      <code class="classname">BasePage</code>. The <code class="classname">BorderPage</code> class
+      should not include common logic, other than that required for rendering the
+      border template. Common page logic should be defined in the
+      <code class="classname">BasePage</code> class.
+      </p><p>To prevent these base Page classes being auto mapped, and becoming
+      directly acessible web pages, ensure that there are no page templates which
+      could match their class name. For example the <code class="classname">BorderPage</code>
+      class above will not be auto mapped to <code class="filename">border-template.htm</code>.
+      </p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch05.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch05.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch05s03.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">Chapter&nbsp;5.&nbsp;Best Practices&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;5.3.&nbsp;Page Auto Mapping</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch05s03.html b/org.apache.click.eclipse/documentation/user-guide/ch05s03.html
new file mode 100644
index 0000000..de81479
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch05s03.html
@@ -0,0 +1,23 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>5.3.&nbsp;Page Auto Mapping</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Best Practices"><link rel="prev" href="ch05s02.html" title="5.2.&nbsp;Packages and Classes"><link rel="next" href="ch05s04.html" title="5.4.&nbsp;Navigation"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">5.3.&nbsp;Page Auto Mapping</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch05s02.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;5.&nbsp;Best Practices</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch05s04.html">Next</a></td></tr></table><hr></div><div class="sect1" title="5.3.&nbsp;Page Auto Mapping"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="automapping"></a>5.3.&nbsp;Page Auto Mapping</h2></div></div></div><p>You should use the Click page automapping configuration feature.
+    See the <a class="link" href="ch04s02.html#application-automapping" title="4.2.3.1.&nbsp;Page Automapping">Page Automapping</a>
+    topic for details.
+    </p><p>Automapping will save you from having to manually configure URL path to
+    Page class mappings in your <code class="filename">click.xml</code> file. If you follow
+    this convention it is very easy to maintain and refactor applications.
+    </p><p>You can also quickly determine what the corresponding Page class is for a
+    page HTML template and visa versa, and if you use the ClickIDE Eclipse plugin
+    you can switch between a page's class and template by pressing Ctrl+Alt+S.
+    </p><p>An example <code class="filename">click.xml</code> automapping configuration is
+    provided below (automapping is enabled by default):
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;click-app&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.dashboard.page"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/click-app&gt;</span></pre><p>To see how the page templates are mapped to Page classes set the application
+    <a class="link" href="ch04s02.html#application-mode" title="4.2.6.&nbsp;Mode">mode</a> to
+    <code class="literal">debug</code> and at startup the mappings will be listed out. An
+    example Click startup listing is provided below:
+    </p><div class="literallayout"><p>[Click]&nbsp;[debug]&nbsp;automapped&nbsp;pages:<br>
+[Click]&nbsp;[debug]&nbsp;/category-tree.htm&nbsp;-&gt;&nbsp;com.mycorp.dashboard.page.CategoryTree<br>
+[Click]&nbsp;[debug]&nbsp;/process-list.htm&nbsp;-&gt;&nbsp;com.mycorp.dashboard.page.ProcessList<br>
+[Click]&nbsp;[debug]&nbsp;/user-list.htm&nbsp;-&gt;&nbsp;com.mycorp.dashboard.page.UserList</p></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch05s02.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch05.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch05s04.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">5.2.&nbsp;Packages and Classes&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;5.4.&nbsp;Navigation</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch05s04.html b/org.apache.click.eclipse/documentation/user-guide/ch05s04.html
new file mode 100644
index 0000000..f0e4fd2
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch05s04.html
@@ -0,0 +1,52 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>5.4.&nbsp;Navigation</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Best Practices"><link rel="prev" href="ch05s03.html" title="5.3.&nbsp;Page Auto Mapping"><link rel="next" href="ch05s05.html" title="5.5.&nbsp;Templating"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">5.4.&nbsp;Navigation</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch05s03.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;5.&nbsp;Best Practices</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch05s05.html">Next</a></td></tr></table><hr></div><div class="sect1" title="5.4.&nbsp;Navigation"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="navigation"></a>5.4.&nbsp;Navigation</h2></div></div></div><p> When navigating between Pages using forwards and redirects, you should
+    refer to the target page using the Page class rather than using path. This
+    provides you compile time checking and will save you from having to update
+    path strings in Java code if you move pages about.
+    </p><p>To forward to another page using the Page class:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> CustomerListPage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> ActionLink customerLink = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> ActionLink(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">this</span>,<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"onCustomerClick"</span>);
+
+    ..
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onCustomerClick() {
+        Integer id = customerLink.getValueInteger();
+        Customer customer = getCustomerService().getCustomer(id);
+
+        CustomerDetailPage customerDetailPage = (CustomerDetailPage)
+            getContext().createPage(CustomerDetailPage.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>);
+
+        customerDetailPage.setCustomer(customer);
+        setForward(customerDetailPage);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+    }
+}</pre><p>To redirect to another page using the Page class you can obtain the pages
+    path from the <code class="classname">Context</code>. In the example below we are passing
+    through the customer id as a request parameter to the target page.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> CustomerListPage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> ActionLink customerLink = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> ActionLink(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">this</span>, <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"onCustomerClick"</span>);
+
+    ..
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onCustomerClick() {
+        String id = customerLink.getValueInteger();
+
+        String path = getContext().getPagePath(CustomerDetailPage.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>);
+        setRedirect(path + <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"?id="</span> + id);
+
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+    }
+}</pre><p>A quick way of redirecting to another page is to simply refer to the target
+    class. The example below logs a user out, by invalidating their session, and
+    then redirects them to the application home page.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">boolean</span> onLogoutClick() {
+    getContext().getSession().invalidate();
+
+    setRedirect(HomePage.<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span>);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> false;
+}</pre></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch05s03.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch05.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch05s05.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">5.3.&nbsp;Page Auto Mapping&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;5.5.&nbsp;Templating</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch05s05.html b/org.apache.click.eclipse/documentation/user-guide/ch05s05.html
new file mode 100644
index 0000000..6fe3998
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch05s05.html
@@ -0,0 +1,8 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>5.5.&nbsp;Templating</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Best Practices"><link rel="prev" href="ch05s04.html" title="5.4.&nbsp;Navigation"><link rel="next" href="ch05s06.html" title="5.6.&nbsp;Menus"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">5.5.&nbsp;Templating</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch05s04.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;5.&nbsp;Best Practices</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch05s06.html">Next</a></td></tr></table><hr></div><div class="sect1" title="5.5.&nbsp;Templating"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="templating"></a>5.5.&nbsp;Templating</h2></div></div></div><p>Use Page templating it is highly recommended. Page templates provide
+    numerous advantages including:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>greatly reduce the amount of HTML you need to maintain</p></li><li class="listitem"><p>ensure you have a common look and feel across your application</p></li><li class="listitem"><p>make global application changes very easy</p></li></ul></div><p>To see how to use templates see the
+    <a class="link" href="ch02s06.html" title="2.6.&nbsp;Page Templating">Page Templating</a> topic. Also see the
+    Click <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../examples.html" target="_blank">Examples</a> use of page templating.
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch05s04.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch05.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch05s06.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">5.4.&nbsp;Navigation&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;5.6.&nbsp;Menus</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch05s06.html b/org.apache.click.eclipse/documentation/user-guide/ch05s06.html
new file mode 100644
index 0000000..7310b34
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch05s06.html
@@ -0,0 +1,25 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>5.6.&nbsp;Menus</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Best Practices"><link rel="prev" href="ch05s05.html" title="5.5.&nbsp;Templating"><link rel="next" href="ch05s07.html" title="5.7.&nbsp;Logging"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">5.6.&nbsp;Menus</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch05s05.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;5.&nbsp;Best Practices</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch05s07.html">Next</a></td></tr></table><hr></div><div class="sect1" title="5.6.&nbsp;Menus"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="menus"></a>5.6.&nbsp;Menus</h2></div></div></div><p> For many applications using the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/control/Menu.html" target="_blank">Menu</a>
+    control to centralize application navigation is very useful. Menus are
+    defined in a <code class="filename">WEB-INF/menu.xml</code> file which is very easy to
+    change.
+    </p><p>A menu is typically defined in the a page border template so they are
+    available through out the application. The Menu control does not support HTML
+    rendering, so you need to define a Velocity macro to programmatically render
+    the menu. You would call the macro in your border template with code like this:
+    </p><div class="literallayout"><p><span class="symbol">#</span><code class="varname">writeMenu</code>(<span class="symbol">$</span>rootMenu)</p></div><p>An advantage of using a macro to render your menu is that you can reuse
+    the code across different applications, and to modify an applications menu you
+    simply need to edit the <code class="filename">WEB-INF/menu.xml</code> file. A good
+    place to define your macros is in the webroot <code class="filename">/macro.vm</code>
+    file as it is automatically included by Click.
+    </p><p>Using macros you can create dynamic menu behaviour such as only rendering
+    menu items a user is authorized to access with
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/control/Menu.html#isUserInRoles()" target="_blank">isUserInRoles()</a>.
+    </p><div class="literallayout"><p><span class="command"><strong>#if</strong></span>&nbsp;(<span class="symbol">$</span>menu.isUserInRoles())<br>
+&nbsp;&nbsp;&nbsp;..<br>
+<span class="command"><strong>#end</strong></span></p></div><p>You can also use JavaScript to add dynamic behaviour such as drop down menus,
+      for example see the Menu page in Click
+      <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../examples.html" target="_blank">Examples</a>.
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch05s05.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch05.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch05s07.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">5.5.&nbsp;Templating&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;5.7.&nbsp;Logging</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch05s07.html b/org.apache.click.eclipse/documentation/user-guide/ch05s07.html
new file mode 100644
index 0000000..4432bae
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch05s07.html
@@ -0,0 +1,70 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>5.7.&nbsp;Logging</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Best Practices"><link rel="prev" href="ch05s06.html" title="5.6.&nbsp;Menus"><link rel="next" href="ch05s08.html" title="5.8.&nbsp;Error Handling"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">5.7.&nbsp;Logging</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch05s06.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;5.&nbsp;Best Practices</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch05s08.html">Next</a></td></tr></table><hr></div><div class="sect1" title="5.7.&nbsp;Logging"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="logging"></a>5.7.&nbsp;Logging</h2></div></div></div><p> 
+    For application logging you should use one of the well established 
+    logging libraries such as Java Util Logging (JUL) or Log4J.
+    </p><p>
+    The library you use will largely depend upon the application server you are targeting.
+    For Apache Tomcat or RedHat JBoss the  
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://logging.apache.org/log4j/" target="_blank">Log4j</a> library is a good 
+    choice. While for the IBM WebSphere or Oracle WebLogic application servers Java Util
+    Logging is better choice as this library is better supported.
+    </p><p>
+    If you have to target multiple application servers you should consider using the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://www.slf4j.org/" target="_blank">SLF4J</a> library which uses compile time bindings
+    to an underlying logging implementation. 
+    </p><p>
+    As a general principle you should
+    probably avoid <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://jakarta.apache.org/commons/logging/" target="_blank">Commons Logging</a> 
+    because of the class loading issues associated with it. If you are using
+    Commons Logging please make sure you have the latest version.
+    </p><p>
+    It is a best place to define a logger method in a common base page, for example:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> BasePage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">protected</span> Logger logger;
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> Logger getLogger() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (logger == null) {
+            logger = Logger.getLogger(getClass());
+        }
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> logger;
+    }
+}</pre><p>Using this pattern all your application bases should extend
+    <code class="classname">BasePage</code> so they can use the
+    <code class="methodname">getLogger()</code> method.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> CustomerListPage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> BasePage {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onGet() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">try</span> {
+            ..
+        } <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">catch</span> (Exception e) {
+            getLogger().error(e);
+        }
+    }
+}</pre><p>If you have some very heavy debug statement you should possibly use an
+    <code class="methodname">isDebugEnabled</code> switch so it is not invoked if debug is
+    not required.
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> CustomerListPage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> BasePage {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onGet() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (getLogger().isDebugEnabled()) {
+            String msg = ..
+
+            getLogger().debug(msg);
+        }
+
+        ..
+    }
+}</pre><p>
+    Please note the Click logging facility is not designed for application use,
+    and is for Click internal use only. When Click is running in
+    <code class="literal">production</code> mode it will not produce any logging output.
+    By default Click logs to the console using
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/service/ConsoleLogService.html" target="_blank">ConsoleLogService</a>. 
+    </p><p>
+    If you need to configure Click to log to an alternative destination please configure a LogService such as
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/service/JdkLogService.html" target="_blank">JdkLogService</a>,
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/service/Log4JLogService.html" target="_blank">Log4JLogService</a> or
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/service/Slf4jLogService.html" target="_blank">Slf4jLogService</a>.
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch05s06.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch05.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch05s08.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">5.6.&nbsp;Menus&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;5.8.&nbsp;Error Handling</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch05s08.html b/org.apache.click.eclipse/documentation/user-guide/ch05s08.html
new file mode 100644
index 0000000..e23e5ff
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch05s08.html
@@ -0,0 +1,28 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>5.8.&nbsp;Error Handling</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Best Practices"><link rel="prev" href="ch05s07.html" title="5.7.&nbsp;Logging"><link rel="next" href="ch05s09.html" title="5.9.&nbsp;Performance"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">5.8.&nbsp;Error Handling</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch05s07.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;5.&nbsp;Best Practices</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch05s09.html">Next</a></td></tr></table><hr></div><div class="sect1" title="5.8.&nbsp;Error Handling"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="error-handling"></a>5.8.&nbsp;Error Handling</h2></div></div></div><p> In Click unhandled errors are directed to the
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/ErrorPage.html" target="_blank">ErrorPage</a>
+    for display. If applications require additional error handling they can create
+    and register a custom error page in <code class="filename">WEB-INF/click.xml</code>.
+    For example:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;pages</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">package</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"com.mycorp.page"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">automapping</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"annotation"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;page</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">path</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"click/error.htm"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">classname</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"ErrorPage"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/pages&gt;</span></pre><p>Generally applications handle transactional errors using service layer code
+    or via a servlet
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/Filter.html" target="_blank">Filter</a>
+    and would not need to include error handling logic in an error page.
+    </p><p>Potential uses for a custom error page include custom logging. For example
+    if an application requires unhandled errors to be logged to an application
+    log (rather than System.out) then a custom
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/util/ErrorPage.html" target="_blank">ErrorPage</a>
+    could be configured. An example <code class="classname">ErrorPage</code> error logging
+    page is provided below:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">package</span> com.mycorp.page.ErrorPage;
+..
+
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> ErrorPage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> org.apache.click.util.ErrorPage {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onDestory() {
+        Logger.getLogger(getClass()).error(getError());
+    }
+}</pre></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch05s07.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch05.html">Up</a></td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch05s09.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">5.7.&nbsp;Logging&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;5.9.&nbsp;Performance</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/ch05s09.html b/org.apache.click.eclipse/documentation/user-guide/ch05s09.html
new file mode 100644
index 0000000..310cd80
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/ch05s09.html
@@ -0,0 +1,109 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>5.9.&nbsp;Performance</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="up" href="ch05.html" title="Chapter&nbsp;5.&nbsp;Best Practices"><link rel="prev" href="ch05s08.html" title="5.8.&nbsp;Error Handling"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">5.9.&nbsp;Performance</th></tr><tr><td width="20%" align="left"><a accesskey="p" href="ch05s08.html">Prev</a>&nbsp;</td><th width="60%" align="center">Chapter&nbsp;5.&nbsp;Best Practices</th><td width="20%" align="right">&nbsp;</td></tr></table><hr></div><div class="sect1" title="5.9.&nbsp;Performance"><div class="titlepage"><div><div><h2 class="title" style="clear: both"><a name="performance"></a>5.9.&nbsp;Performance</h2></div></div></div><p>Yahoo published a list of
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://developer.yahoo.com/performance/rules.html" target="_blank">best practices</a>
+    for improving web application performance.
+    </p><p>Click Framework provides a
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../extras-api/org/apache/click/extras/filter/PerformanceFilter.html" target="_blank">PerformanceFilter</a>
+    which caters for some of these rules. However not all rules can be easily automated.
+    </p><p>This section outlines how to apply some important rules which are not
+    covered by the PerformanceFilter namely,
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://developer.yahoo.com/performance/rules.html#num_http" target="_blank">Minimize HTTP Requests (by combining files)</a>
+    and <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://developer.yahoo.com/performance/rules.html#minify" target="_blank">Minify JavaScript and CSS</a>.
+    </p><p>The Rule, <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://developer.yahoo.com/performance/rules.html#num_http" target="_blank">Minimize HTTP Requests</a>,
+    also mentions <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://alistapart.com/articles/sprites" target="_blank">CSS Sprites</a>,
+    a method for combining multiple images into a single master image. CSS Sprites
+    can boost performance when your application has many images, however it is
+    harder to create and maintain. Note that CSS Sprites is not covered here.
+    </p><p>It is worth pointing out that its not necessary to optimize
+    every page in your application. Instead concentrate on popular pages, for
+    example a web site's <span class="emphasis"><em>Home Page</em></span> would be a good
+    candidate.
+    </p><p>There are a couple of tools that are useful in applying the rules
+    "Minimize HTTP Requests" and "Minify JavaScript and CSS":
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://developer.yahoo.com/yui/compressor/" target="_blank">YUICompressor</a>
+            - minifies and compresses JavaScript and CSS files so less bytes have to
+            be transferred across the wire.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://code.google.com/p/javaflight-code/" target="_blank">Ant Task for YUICompressor</a>
+            - an Ant task that uses YUICompressor to compress JavaScript and CSS files.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://www.crockford.com/javascript/jsmin.html" target="_blank">JSMin</a>
+            - similar to YUICompressor but only minifies (remove whitespace and newlines)
+            JavaScript files and does no compression at all. An advantage of JSMin
+            over YUICompressor is that its faster and can be used at runtime to minify
+            JavaScript, while YUICompressor is most often used at build time.
+        </p></li></ul></div><p>Below are some articles outlining how to use YUICompressor and Ant to
+    concatenate and compress JavaScript and CSS files:
+    </p><div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://www.julienlecomte.net/blog/2007/09/16/" target="_blank">Article</a>
+            explaining how to use Ant and YUICompressor for compression.
+        </p></li><li class="listitem"><p>
+          <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://javaflight.blogspot.com/2008/01/introducing-yui-compressor-ant-task.html" target="_blank">Article</a>
+            outlining how to use a special YUICompressor Ant Task for compression.
+        </p></li></ul></div><p>Using one of the approaches above you can concatenate and compress all
+    JavaScript and CSS for your Pages into two separate files, for example
+    <code class="filename">home-page.css</code>
+    and <code class="filename">home-page.js</code>. Note that the two files must include
+    all the JavaScript and CSS that is generated by the Page and its Controls.
+    Then you can instruct Click to <span class="emphasis"><em>only</em></span> include the two
+    compressed files, home-page.css and home-page.js.
+    </p><p>The Click Page class exposes the property
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#setIncludeControlHeadElements(boolean)" target="_blank">includeControlHeadElements</a>
+    that indicates whether Controls have their CSS and JavaScript resources
+    included or not.
+    </p><p>To optimize Page loading one can override
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#getHeadElements()" target="_blank">Page.getHeadElements()</a>,
+    and import the JavaScript and CSS files and then set the property
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="../../click-api/org/apache/click/Page.html#setIncludeControlHeadElements(boolean)" target="_blank">includeControlHeadElements</a>
+    to <code class="literal">false</code>, indicating that Controls won't contribute
+    their own JavaScript and CSS resources.
+    </p><p>Here is an example:</p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">class</span> HomePage <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">extends</span> Page {
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">private</span> Form form = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> Form(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"form"</span>);
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">void</span> onInit() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="com">// Indicate that Controls should not import their head elements</span>
+        setIncludeControlHeadElements(false);
+
+        form.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> EmailField(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"email"</span>);
+        addControl(form);
+    }
+
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">public</span> List getHeadElements() {
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">if</span> (headElements == null) {
+            headElements = <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">super</span>.getHeadElements();
+
+            headElements.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> CssImport(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/assets/css/home-page.css"</span>));
+            headElements.add(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">new</span> JsImport(<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="str">"/assets/js/home-page.js"</span>));
+        }
+        <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="kwd">return</span> headElements;
+    }
+}</pre><p>Using the following <code class="filename">border-template.htm</code>:
+    </p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;title&gt;</span>Click Examples<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/title&gt;</span>
+    ${headElements}
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+  ...
+
+  ${jsElements}
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>the rendered HTML will include one CSS and one JavaScript import:</p><pre class="programlisting"><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;html&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;head&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;title&gt;</span>Click Examples<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/title&gt;</span>
+    <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;link</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/css"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">rel</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"stylesheet"</span>
+          <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">href</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"/click-examples/assets/css/home-page.css"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">title</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"Style"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">/&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/head&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;body&gt;</span>
+
+  ...
+
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;script</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">type</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"text/javascript"</span> <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="atn">src</span>=<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="pln">"/click-examples/assets/js/home-page.js"</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&gt;</span><span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/script&gt;</span>
+  <span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/body&gt;</span>
+<span xmlns:fo="http://www.w3.org/1999/XSL/Format" class="tag">&lt;/html&gt;</span></pre><p>A live demo is available
+    <a xmlns:fo="http://www.w3.org/1999/XSL/Format" class="external" href="http://www.avoka.com/click-examples/general/page-imports-example.htm" target="_blank">here</a>
+    </p></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="ch05s08.html">Prev</a>&nbsp;</td><td width="20%" align="center"><a accesskey="u" href="ch05.html">Up</a></td><td width="40%" align="right">&nbsp;</td></tr><tr><td width="40%" align="left" valign="top">5.8.&nbsp;Error Handling&nbsp;</td><td width="20%" align="center"><a accesskey="h" href="index.html">Home</a></td><td width="40%" align="right" valign="top">&nbsp;</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/user-guide/css/stylesheet.css b/org.apache.click.eclipse/documentation/user-guide/css/stylesheet.css
new file mode 100644
index 0000000..9e686e5
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/css/stylesheet.css
@@ -0,0 +1,363 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+html {
+    padding:        0pt;
+    margin:         0pt;
+}
+
+body {
+    margin-top:     1em;
+    margin-bottom:  1em;
+    margin-right:   15px;
+    margin-left:    15px;
+    
+    font-family:    verdana,arial,helvetica,lucida-sans,sans-serif;
+    font-size:      12px;
+}
+
+div {
+    margin:         0pt;
+}
+
+p {
+    text-align:     justify;
+    margin-bottom:  .6em;
+    line-height:    1.2;
+    font-size:      12px;
+}
+
+hr {
+    margin-top:     .6em;
+    margin-bottom:  .6em;
+    margin-left:    0pt;
+    margin-right:   0pt;
+    border-top:   1px solid #c0c0c0;
+    height: 0px;
+}
+
+h1,h2,h3,h4,h5 {
+    color:          #000000;
+}
+
+a {
+   text-decoration: underline;
+}
+
+a:hover {
+   text-decoration: underline;
+}
+
+a:visited {
+  color: blue;
+}
+
+h1,h2,h3,h4,h5 {
+    line-height:    1.3;
+    margin-top:     1.5em;
+}
+
+h1.title {
+    text-align:     left;
+
+    margin-top:     2em;
+    margin-bottom:  2em;
+    margin-left:    0pt;
+    margin-right:   0pt;
+    color:          #000080;
+}
+
+h2.subtitle, h3.subtitle {
+    text-align:     left;
+    margin-top:     2em;
+    margin-bottom:  2em;
+    text-transform: uppercase;
+}
+
+h3.author, p.othercredit {
+    font-size:      0.9em;
+    font-weight:    normal;
+    font-style:     oblique;
+    text-align:     left;
+    color:          #525D76;
+}
+
+div.titlepage {
+}
+
+div.section {
+}
+
+div.authorgroup
+{
+    text-align:     left;
+    margin-bottom:  3em;
+    display:        block;
+}
+
+div.toc, div.list-of-examples, div.list-of-figures {
+    margin-bottom:  3em;
+}
+
+.toc dt {
+    padding-bottom: 4px;
+}
+
+div.itemizedlist {
+    margin-top:     0.5em;
+    margin-bottom:  0.5em;
+}
+
+ol,ul {
+}
+
+li {
+}
+
+pre {
+    margin:         .75em 0;
+    line-height:    1.0;
+    color:          black;
+}
+
+pre.programlisting {
+    font-size:      9pt;
+    padding:        5pt 2pt;
+    border:         1pt solid black;
+    background:     #eeeeee;
+    font-family:    "Courier New",courier;
+}
+
+div.table {
+    margin:         1em;
+    padding:        0.5em;
+    text-align:     center;
+}
+
+div.table table {
+    display:        block;
+}
+
+div.table td {
+    padding-right:  5px;
+    padding-left:   5px;
+}
+
+div.table p.title {
+    text-align:     center;
+    margin-left:    5%;
+    margin-right:   5%;
+}
+
+p.releaseinfo, .copyright {
+    font-size:      0.7em;
+    text-align:     left;
+    margin:         0px;
+    padding:        0px;
+}
+
+div.example {
+
+}
+
+div.note, div.important, div.informalexample, div.tip, div.caution {
+    margin:         1em;
+    padding:        0.5em;
+    border:         1px solid gray;
+    background-color: #f8f8e0;
+}
+
+div.important th, div.note th, div.tip th {
+    text-align:     left;
+    border-bottom:  solid 1px gray;
+}
+
+div.navheader, div.navheader table {
+    font-family:    sans-serif;
+    font-size:      12px;
+}
+
+div.navfooter, div.navfooter table {
+    font-family:    sans-serif;
+    font-size:      12px;
+}
+div.navfooter {
+    margin-top: 1em;
+}
+
+div.figure {
+    text-align:     left;
+    margin-top:     1em;
+    margin-bottom:  1em;
+}
+
+div.figure p.title {
+    text-align:     left;
+    margin:         0.5em;
+    padding:        0.5em;
+}
+
+div.example p.title {
+}
+
+div.figure img {
+    padding:        0.5em;
+    margin:         0.5em;
+}
+
+div.revhistory {
+    font-size:      0.8em;
+    width:          90%;
+    margin-left:    5%;
+    margin-top:     3em;
+    margin-bottom:  3em;
+}
+
+div.revhistory table {
+    font-family:    sans-serif;
+    font-size:      12px;
+	  border-collapse: collapse;
+}
+
+div.revhistory table tr {
+	border:         solid 1px gray;
+}
+
+div.revhistory table th {
+	border: none;
+}
+
+div.literallayout {
+    background-color: #EEEEEE;
+    border: 1px solid #AAAAAA;
+    padding: 5pt 1em;
+    line-height: normal;
+    font-family: "Courier New",courier;
+}
+
+code.filename, code.filename span.pln {
+}
+
+code.varname, code.varname span.pln, code.varname span.atv, code.varname span.atn {
+    color: blue;
+    font-weight: normal;
+}
+
+span.symbol, span.symbol span.pln, span.symbol span.atn, span.symbol span.tag,
+span.symbol span.atv {
+    color: red;
+    font-weight: normal;
+}
+
+span.command, span.command span.pln {
+    color: #7F0055;
+}
+
+span.token, span.token span.pln, span.token span.atv {
+    color: maroon;
+}
+
+span.package {
+    font-family: monospace;
+}
+
+code.computeroutput {
+    background-color: #FFFFC0;
+    border: 1px solid #A7BCD6;
+    margin: 0.5em;
+    padding: 0.5em;
+}
+
+div.informaltable table {
+  border: 1px solid black;
+}
+
+div.informaltable th {
+    padding: 6px 10px 2px;
+    background-color: navy;
+    color: white;
+}
+
+div.calloutlist td {
+    padding-right: 10px;
+}
+
+span.bold {
+    font-weight: bold;
+}
+
+a.external {
+  background: url(../images/external.png) center right no-repeat;
+  padding-right: 14px;
+}
+
+div.screenshot {
+  /* Clear the float using overflow: hidden*/
+	overflow: hidden;
+  /* IE6 doesn't clear float unless we set width*/
+	width: 100%;
+}
+
+div.screenshot div {
+  border: 1px solid gray;
+  padding: 1em;
+  margin-top: 1em;
+  margin-bottom: 1em;
+  float: left;
+}
+
+/* Syntax highlighting styles start */
+.str{color:#2A00FF;}
+.kwd{color:#7F0055;
+    font-weight:bold;}
+.com{color:#3F7F5F;}
+.typ{color:#000;}
+.lit{color:#066;}
+.pun{color:#660;}
+.pln{color:#000;}
+.tag{color:#000099;
+    font-weight:bold;}
+.atn{color:#009900;}
+.atv{color:#000;}
+.dec{color:#606;}
+
+pre.programlisting{
+    padding:1em;
+    border:1px solid #888;
+    text-align: left;
+    line-height: normal;
+}
+
+@media print{
+    .str{color:#2A00FF;}
+    .kwd{color:#7F0055;
+        font-weight:bold;}
+    .com{color:#3F7F5F;
+        font-style:italic;}
+    .typ{color:#000;
+        font-weight:bold;}
+    .lit{color:#044;}
+    .pun{color:#440;}
+    .pln{color:#000;}
+    .tag{color:#000099;
+        font-weight:bold;}
+    .atn{color:#009900;}
+    .atv{color:#000;}
+}
+/* Syntax highlighting styles end */
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/annot-close.png b/org.apache.click.eclipse/documentation/user-guide/images/annot-close.png
new file mode 100644
index 0000000..b9e1a0d
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/annot-close.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/annot-open.png b/org.apache.click.eclipse/documentation/user-guide/images/annot-open.png
new file mode 100644
index 0000000..71040ec
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/annot-open.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/best-practices/packages-classes.png b/org.apache.click.eclipse/documentation/user-guide/images/best-practices/packages-classes.png
new file mode 100644
index 0000000..f733011
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/best-practices/packages-classes.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/blank.png b/org.apache.click.eclipse/documentation/user-guide/images/blank.png
new file mode 100644
index 0000000..764bf4f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/blank.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/1.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/1.gif
new file mode 100644
index 0000000..9e7a87f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/1.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/1.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/1.png
new file mode 100644
index 0000000..7d47343
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/1.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/1.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/1.svg
new file mode 100644
index 0000000..e2e87dc
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/1.svg
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M10.428,10.411h0.56c3.78,0,4.788-1.96,4.872-3.444h3.22v19.88h-3.92V13.154h-4.732V10.411z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/10.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/10.gif
new file mode 100644
index 0000000..e80f7f8
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/10.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/10.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/10.png
new file mode 100644
index 0000000..997bbc8
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/10.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/10.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/10.svg
new file mode 100644
index 0000000..4740f58
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/10.svg
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.815,10.758h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76v17.04h-3.36V13.11H3.815V10.758z"/>
+		<path style="fill:#FFFFFF;" d="M22.175,7.806c4.009,0,5.904,2.76,5.904,8.736c0,5.975-1.896,8.76-5.904,8.76
+			c-4.008,0-5.904-2.785-5.904-8.76C16.271,10.566,18.167,7.806,22.175,7.806z M22.175,22.613c1.921,0,2.448-1.68,2.448-6.071
+			c0-4.393-0.527-6.049-2.448-6.049c-1.92,0-2.448,1.656-2.448,6.049C19.727,20.934,20.255,22.613,22.175,22.613z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/11.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/11.gif
new file mode 100644
index 0000000..67f91a2
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/11.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/11.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/11.png
new file mode 100644
index 0000000..ce47dac
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/11.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/11.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/11.svg
new file mode 100644
index 0000000..09a0b2c
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/11.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M5.209,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H5.209V10.412z"/>
+		<path style="fill:#FFFFFF;" d="M18.553,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.359V12.764h-4.056V10.412z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/12.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/12.gif
new file mode 100644
index 0000000..54c4b42
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/12.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/12.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/12.png
new file mode 100644
index 0000000..31daf4e
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/12.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/12.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/12.svg
new file mode 100644
index 0000000..9794044
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/12.svg
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M4.813,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H4.813V10.412z"/>
+		<path style="fill:#FFFFFF;" d="M17.316,13.484c0-5.545,4.056-6.024,5.568-6.024c3.265,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.553,5.544c-2.256,1.584-3.432,2.353-3.815,3.145h7.392V24.5h-11.64c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.353-2.424c-2.352,0-2.423,1.944-2.447,3.192H17.316z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/13.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/13.gif
new file mode 100644
index 0000000..dd5d7d9
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/13.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/13.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/13.png
new file mode 100644
index 0000000..14021a8
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/13.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/13.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/13.svg
new file mode 100644
index 0000000..64268bb
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/13.svg
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.813,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H3.813V10.412z"/>
+		<path style="fill:#FFFFFF;" d="M20.611,14.636h0.529c1.008,0,2.855-0.096,2.855-2.304c0-0.624-0.288-2.185-2.137-2.185
+			c-2.303,0-2.303,2.185-2.303,2.784h-3.12c0-3.191,1.8-5.472,5.64-5.472c2.279,0,5.279,1.152,5.279,4.752
+			c0,1.728-1.08,2.808-2.039,3.24V15.5c0.6,0.168,2.568,1.056,2.568,3.96c0,3.216-2.377,5.496-5.809,5.496
+			c-1.607,0-5.928-0.36-5.928-5.688h3.288l-0.024,0.024c0,0.912,0.24,2.976,2.496,2.976c1.344,0,2.52-0.911,2.52-2.808
+			c0-2.328-2.256-2.424-3.816-2.424V14.636z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/14.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/14.gif
new file mode 100644
index 0000000..3d7a952
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/14.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/14.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/14.png
new file mode 100644
index 0000000..64014b7
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/14.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/14.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/14.svg
new file mode 100644
index 0000000..469aa97
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/14.svg
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M4.146,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H4.146V10.412z"/>
+		<path style="fill:#FFFFFF;" d="M28.457,20.732h-1.896V24.5h-3.36v-3.768h-6.72v-2.904L22.746,7.46h3.815v10.656h1.896V20.732z
+			 M23.201,18.116c0-4.128,0.072-6.792,0.072-7.32h-0.048l-4.272,7.32H23.201z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/15.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/15.gif
new file mode 100644
index 0000000..1c9183d
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/15.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/15.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/15.png
new file mode 100644
index 0000000..0d65765
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/15.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/15.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/15.svg
new file mode 100644
index 0000000..8202233
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/15.svg
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.479,11.079h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76v17.04h-3.36V13.43H3.479V11.079z"/>
+		<path style="fill:#FFFFFF;" d="M19.342,14.943c0.625-0.433,1.392-0.937,3.048-0.937c2.279,0,5.16,1.584,5.16,5.496
+			c0,2.328-1.176,6.121-6.192,6.121c-2.664,0-5.376-1.584-5.544-5.016h3.36c0.144,1.391,0.888,2.326,2.376,2.326
+			c1.607,0,2.544-1.367,2.544-3.191c0-1.512-0.72-3.047-2.496-3.047c-0.456,0-1.608,0.023-2.256,1.223l-3-0.143l1.176-9.361h9.36
+			v2.832h-6.937L19.342,14.943z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/16.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/16.svg
new file mode 100644
index 0000000..01d6bf8
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/16.svg
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.813,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H3.813V10.412z"/>
+		<path style="fill:#FFFFFF;" d="M24.309,11.78c-0.097-0.96-0.721-1.633-1.969-1.633c-2.184,0-2.688,2.496-2.808,4.704L19.58,14.9
+			c0.456-0.624,1.296-1.416,3.191-1.416c3.529,0,5.209,2.712,5.209,5.256c0,3.72-2.28,6.216-5.568,6.216
+			c-5.16,0-6.168-4.32-6.168-8.568c0-3.24,0.432-8.928,6.336-8.928c0.695,0,2.641,0.264,3.48,1.104
+			c0.936,0.912,1.271,1.416,1.584,3.217H24.309z M22.172,16.172c-1.271,0-2.568,0.792-2.568,2.928c0,1.849,1.056,3.168,2.664,3.168
+			c1.225,0,2.353-0.936,2.353-3.239C24.62,16.868,23.229,16.172,22.172,16.172z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/17.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/17.svg
new file mode 100644
index 0000000..0a04c55
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/17.svg
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.479,11.079h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76v17.04h-3.36V13.43H3.479V11.079z"/>
+		<path style="fill:#FFFFFF;" d="M27.838,11.006c-1.631,1.776-5.807,6.816-6.215,14.16h-3.457c0.36-6.816,4.632-12.24,6.072-13.776
+			h-8.472l0.072-2.976h12V11.006z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/18.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/18.svg
new file mode 100644
index 0000000..1cb891b
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/18.svg
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M4.813,10.412h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76V24.5h-3.36V12.764H4.813V10.412z"/>
+		<path style="fill:#FFFFFF;" d="M23.172,24.956c-4.392,0-5.904-2.856-5.904-5.185c0-0.863,0-3.119,2.592-4.319
+			c-1.344-0.672-2.064-1.752-2.064-3.336c0-2.904,2.328-4.656,5.304-4.656c3.528,0,5.4,2.088,5.4,4.44
+			c0,1.464-0.6,2.712-1.968,3.432c1.632,0.815,2.544,1.896,2.544,4.104C29.076,21.596,27.684,24.956,23.172,24.956z M23.124,16.916
+			c-1.224,0-2.4,0.792-2.4,2.64c0,1.632,0.936,2.712,2.472,2.712c1.752,0,2.424-1.512,2.424-2.688
+			C25.62,18.38,24.996,16.916,23.124,16.916z M25.284,12.26c0-1.296-0.888-2.112-1.968-2.112c-1.512,0-2.305,0.864-2.305,2.112
+			c0,1.008,0.744,2.112,2.185,2.112C24.516,14.372,25.284,13.484,25.284,12.26z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/19.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/19.svg
new file mode 100644
index 0000000..e6fbb17
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/19.svg
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M4.146,10.746h0.48c3.24,0,4.104-1.681,4.176-2.952h2.76v17.041h-3.36V13.097H4.146V10.746z"/>
+		<path style="fill:#FFFFFF;" d="M20.225,20.898v0.023c0.192,1.176,0.936,1.68,1.968,1.68c1.392,0,2.783-1.176,2.808-4.752
+			l-0.048-0.049c-0.768,1.152-2.088,1.441-3.24,1.441c-3.264,0-5.16-2.473-5.16-5.329c0-4.176,2.472-6.12,5.808-6.12
+			c5.904,0,6,6.36,6,8.76c0,6.601-3.12,8.736-6.192,8.736c-2.904,0-4.992-1.68-5.28-4.391H20.225z M22.434,16.553
+			c1.176,0,2.472-0.84,2.472-2.855c0-1.944-0.841-3.145-2.568-3.145c-0.864,0-2.424,0.433-2.424,2.88
+			C19.913,16.001,21.161,16.553,22.434,16.553z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/2.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/2.gif
new file mode 100644
index 0000000..94d42a3
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/2.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/2.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/2.png
new file mode 100644
index 0000000..5d09341
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/2.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/2.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/2.svg
new file mode 100644
index 0000000..07d0339
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/2.svg
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M9.668,12.328c0-6.469,4.732-7.028,6.496-7.028c3.808,0,6.833,2.24,6.833,6.271
+			c0,3.416-2.213,5.152-4.145,6.469c-2.632,1.848-4.004,2.744-4.452,3.668h8.624v3.472H9.444c0.14-2.324,0.308-4.76,4.62-7.896
+			c3.584-2.604,5.012-3.612,5.012-5.853c0-1.315-0.84-2.828-2.744-2.828c-2.744,0-2.828,2.269-2.856,3.725H9.668z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/20.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/20.svg
new file mode 100644
index 0000000..ccbfd40
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/20.svg
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
+		<path style="fill:#FFFFFF;" d="M23.172,7.46c4.008,0,5.904,2.76,5.904,8.736c0,5.976-1.896,8.76-5.904,8.76
+			s-5.904-2.784-5.904-8.76C17.268,10.22,19.164,7.46,23.172,7.46z M23.172,22.268c1.92,0,2.448-1.68,2.448-6.071
+			c0-4.393-0.528-6.049-2.448-6.049s-2.448,1.656-2.448,6.049C20.724,20.588,21.252,22.268,23.172,22.268z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/21.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/21.svg
new file mode 100644
index 0000000..93ec53f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/21.svg
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M5.306,13.151c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392v2.976H5.114c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H5.306z"/>
+		<path style="fill:#FFFFFF;" d="M19.49,10.079h0.48c3.239,0,4.104-1.681,4.176-2.952h2.761v17.04h-3.361V12.431H19.49V10.079z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/22.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/22.svg
new file mode 100644
index 0000000..f48c5f3
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/22.svg
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
+		<path style="fill:#FFFFFF;" d="M17.316,13.484c0-5.545,4.056-6.024,5.568-6.024c3.265,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.553,5.544c-2.256,1.584-3.432,2.353-3.815,3.145h7.392V24.5h-11.64c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.353-2.424c-2.352,0-2.423,1.944-2.447,3.192H17.316z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/23.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/23.svg
new file mode 100644
index 0000000..6624212
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/23.svg
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
+		<path style="fill:#FFFFFF;" d="M21.612,14.636h0.528c1.008,0,2.855-0.096,2.855-2.304c0-0.624-0.287-2.185-2.136-2.185
+			c-2.304,0-2.304,2.185-2.304,2.784h-3.12c0-3.191,1.8-5.472,5.64-5.472c2.28,0,5.28,1.152,5.28,4.752
+			c0,1.728-1.08,2.808-2.04,3.24V15.5c0.6,0.168,2.568,1.056,2.568,3.96c0,3.216-2.377,5.496-5.809,5.496
+			c-1.607,0-5.928-0.36-5.928-5.688h3.288l-0.024,0.024c0,0.912,0.24,2.976,2.496,2.976c1.344,0,2.521-0.911,2.521-2.808
+			c0-2.328-2.257-2.424-3.816-2.424V14.636z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/24.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/24.svg
new file mode 100644
index 0000000..a3d5525
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/24.svg
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M4.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H4.78c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H4.972z"/>
+		<path style="fill:#FFFFFF;" d="M30.124,20.732h-1.896V24.5h-3.36v-3.768h-6.72v-2.904L24.412,7.46h3.816v10.656h1.896V20.732z
+			 M24.868,18.116c0-4.128,0.071-6.792,0.071-7.32h-0.047l-4.272,7.32H24.868z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/25.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/25.svg
new file mode 100644
index 0000000..56614a9
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/25.svg
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
+		<path style="fill:#FFFFFF;" d="M20.676,14.276c0.624-0.433,1.393-0.937,3.049-0.937c2.279,0,5.16,1.584,5.16,5.496
+			c0,2.328-1.177,6.12-6.193,6.12c-2.664,0-5.375-1.584-5.543-5.016h3.36c0.144,1.392,0.889,2.327,2.376,2.327
+			c1.608,0,2.544-1.367,2.544-3.191c0-1.513-0.72-3.048-2.496-3.048c-0.455,0-1.607,0.023-2.256,1.224l-3-0.144l1.176-9.36h9.36
+			v2.832h-6.937L20.676,14.276z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/26.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/26.svg
new file mode 100644
index 0000000..56faeac
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/26.svg
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
+		<path style="fill:#FFFFFF;" d="M25.309,11.78c-0.097-0.96-0.721-1.633-1.969-1.633c-2.184,0-2.688,2.496-2.808,4.704L20.58,14.9
+			c0.456-0.624,1.296-1.416,3.191-1.416c3.529,0,5.209,2.712,5.209,5.256c0,3.72-2.28,6.216-5.568,6.216
+			c-5.16,0-6.168-4.32-6.168-8.568c0-3.24,0.432-8.928,6.336-8.928c0.695,0,2.641,0.264,3.48,1.104
+			c0.936,0.912,1.271,1.416,1.584,3.217H25.309z M23.172,16.172c-1.271,0-2.568,0.792-2.568,2.928c0,1.849,1.056,3.168,2.664,3.168
+			c1.225,0,2.353-0.936,2.353-3.239C25.62,16.868,24.229,16.172,23.172,16.172z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/27.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/27.svg
new file mode 100644
index 0000000..a75c812
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/27.svg
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
+		<path style="fill:#FFFFFF;" d="M29.172,10.34c-1.632,1.776-5.808,6.816-6.216,14.16H19.5c0.36-6.816,4.632-12.24,6.072-13.776
+			H17.1l0.072-2.976h12V10.34z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/28.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/28.svg
new file mode 100644
index 0000000..7f8cf1a
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/28.svg
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
+		<path style="fill:#FFFFFF;" d="M23.172,24.956c-4.392,0-5.904-2.856-5.904-5.185c0-0.863,0-3.119,2.592-4.319
+			c-1.344-0.672-2.064-1.752-2.064-3.336c0-2.904,2.328-4.656,5.304-4.656c3.528,0,5.4,2.088,5.4,4.44
+			c0,1.464-0.6,2.712-1.968,3.432c1.632,0.815,2.544,1.896,2.544,4.104C29.076,21.596,27.684,24.956,23.172,24.956z M23.124,16.916
+			c-1.224,0-2.4,0.792-2.4,2.64c0,1.632,0.936,2.712,2.472,2.712c1.752,0,2.424-1.512,2.424-2.688
+			C25.62,18.38,24.996,16.916,23.124,16.916z M25.284,12.26c0-1.296-0.888-2.112-1.968-2.112c-1.512,0-2.305,0.864-2.305,2.112
+			c0,1.008,0.744,2.112,2.185,2.112C24.516,14.372,25.284,13.484,25.284,12.26z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/29.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/29.svg
new file mode 100644
index 0000000..cb63adf
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/29.svg
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M3.972,13.484c0-5.545,4.056-6.024,5.568-6.024c3.264,0,5.856,1.92,5.856,5.376
+			c0,2.928-1.896,4.416-3.552,5.544c-2.256,1.584-3.432,2.353-3.816,3.145h7.392V24.5H3.78c0.12-1.992,0.264-4.08,3.96-6.768
+			c3.072-2.232,4.296-3.097,4.296-5.017c0-1.128-0.72-2.424-2.352-2.424c-2.352,0-2.424,1.944-2.448,3.192H3.972z"/>
+		<path style="fill:#FFFFFF;" d="M20.893,20.564v0.023c0.191,1.176,0.936,1.68,1.967,1.68c1.393,0,2.785-1.176,2.809-4.752
+			l-0.048-0.048c-0.769,1.152-2.088,1.44-3.24,1.44c-3.264,0-5.16-2.473-5.16-5.328c0-4.176,2.472-6.12,5.807-6.12
+			c5.904,0,6.001,6.36,6.001,8.76c0,6.601-3.12,8.736-6.192,8.736c-2.904,0-4.992-1.68-5.28-4.392H20.893z M23.1,16.22
+			c1.176,0,2.473-0.84,2.473-2.855c0-1.944-0.84-3.145-2.568-3.145c-0.863,0-2.424,0.433-2.424,2.88
+			C20.58,15.668,21.828,16.22,23.1,16.22z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/3.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/3.gif
new file mode 100644
index 0000000..dd3541a
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/3.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/3.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/3.png
new file mode 100644
index 0000000..ef7b700
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/3.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/3.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/3.svg
new file mode 100644
index 0000000..918be80
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/3.svg
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M15.127,14.005h0.616c1.176,0,3.332-0.112,3.332-2.688c0-0.728-0.336-2.548-2.492-2.548
+			c-2.688,0-2.688,2.548-2.688,3.248h-3.64c0-3.724,2.1-6.384,6.58-6.384c2.66,0,6.16,1.344,6.16,5.544
+			c0,2.016-1.261,3.276-2.38,3.78v0.056c0.699,0.196,2.996,1.232,2.996,4.62c0,3.752-2.772,6.412-6.776,6.412
+			c-1.876,0-6.916-0.42-6.916-6.636h3.836l-0.028,0.027c0,1.064,0.28,3.473,2.912,3.473c1.568,0,2.94-1.064,2.94-3.276
+			c0-2.716-2.632-2.828-4.452-2.828V14.005z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/30.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/30.svg
new file mode 100644
index 0000000..dc43ba1
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/30.svg
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M8.268,14.636h0.528c1.008,0,2.856-0.096,2.856-2.304c0-0.624-0.288-2.185-2.136-2.185
+			c-2.304,0-2.304,2.185-2.304,2.784h-3.12c0-3.191,1.8-5.472,5.64-5.472c2.28,0,5.28,1.152,5.28,4.752
+			c0,1.728-1.08,2.808-2.04,3.24V15.5c0.6,0.168,2.568,1.056,2.568,3.96c0,3.216-2.376,5.496-5.808,5.496
+			c-1.608,0-5.928-0.36-5.928-5.688h3.288l-0.024,0.024c0,0.912,0.24,2.976,2.496,2.976c1.344,0,2.52-0.911,2.52-2.808
+			c0-2.328-2.256-2.424-3.816-2.424V14.636z"/>
+		<path style="fill:#FFFFFF;" d="M23.172,7.46c4.008,0,5.904,2.76,5.904,8.736c0,5.976-1.896,8.76-5.904,8.76
+			s-5.904-2.784-5.904-8.76C17.268,10.22,19.164,7.46,23.172,7.46z M23.172,22.268c1.92,0,2.448-1.68,2.448-6.071
+			c0-4.393-0.528-6.049-2.448-6.049s-2.448,1.656-2.448,6.049C20.724,20.588,21.252,22.268,23.172,22.268z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/4.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/4.gif
new file mode 100644
index 0000000..4bcbf7e
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/4.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/4.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/4.png
new file mode 100644
index 0000000..adb8364
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/4.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/4.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/4.svg
new file mode 100644
index 0000000..8eb6a53
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/4.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M21.891,20.784h-2.212v4.396h-3.92v-4.396h-7.84v-3.389L15.227,5.3h4.452v12.432h2.212V20.784z
+			 M15.759,17.731c0-4.815,0.084-7.924,0.084-8.54h-0.056l-4.984,8.54H15.759z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/5.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/5.gif
new file mode 100644
index 0000000..1c62b4f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/5.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/5.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/5.png
new file mode 100644
index 0000000..4d7eb46
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/5.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/5.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/5.svg
new file mode 100644
index 0000000..ca7a9f2
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/5.svg
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M14.035,14.252c0.728-0.504,1.624-1.092,3.556-1.092c2.66,0,6.02,1.848,6.02,6.411
+			c0,2.717-1.372,7.141-7.224,7.141c-3.108,0-6.272-1.849-6.468-5.853h3.92c0.168,1.624,1.036,2.717,2.772,2.717
+			c1.876,0,2.968-1.597,2.968-3.725c0-1.764-0.839-3.556-2.912-3.556c-0.532,0-1.876,0.028-2.632,1.428l-3.5-0.168l1.372-10.92
+			h10.919v3.304h-8.092L14.035,14.252z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/6.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/6.gif
new file mode 100644
index 0000000..23bc555
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/6.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/6.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/6.png
new file mode 100644
index 0000000..0ba694a
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/6.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/6.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/6.svg
new file mode 100644
index 0000000..783a0b9
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/6.svg
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M19.106,10.673c-0.112-1.12-0.84-1.904-2.296-1.904c-2.548,0-3.136,2.912-3.276,5.488l0.056,0.056
+			c0.532-0.728,1.512-1.651,3.724-1.651c4.116,0,6.077,3.164,6.077,6.131c0,4.34-2.66,7.252-6.497,7.252
+			c-6.02,0-7.196-5.039-7.196-9.996c0-3.78,0.504-10.416,7.392-10.416c0.812,0,3.08,0.308,4.061,1.288
+			c1.092,1.063,1.483,1.652,1.848,3.752H19.106z M16.614,15.797c-1.484,0-2.996,0.924-2.996,3.416c0,2.156,1.232,3.697,3.108,3.697
+			c1.428,0,2.745-1.094,2.745-3.781C19.471,16.609,17.846,15.797,16.614,15.797z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/7.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/7.gif
new file mode 100644
index 0000000..e55ce89
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/7.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/7.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/7.png
new file mode 100644
index 0000000..472e96f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/7.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/7.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/7.svg
new file mode 100644
index 0000000..59b3714
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/7.svg
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M24.28,9.66c-1.904,2.071-6.776,7.951-7.252,16.52h-4.032c0.42-7.952,5.404-14.28,7.084-16.072
+			h-9.884l0.084-3.472h14V9.66z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/8.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/8.gif
new file mode 100644
index 0000000..49375e0
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/8.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/8.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/8.png
new file mode 100644
index 0000000..5e60973
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/8.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/8.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/8.svg
new file mode 100644
index 0000000..c1803a3
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/8.svg
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M16.28,26.712c-5.124,0-6.888-3.332-6.888-6.048c0-1.009,0-3.641,3.024-5.04
+			c-1.568-0.784-2.408-2.044-2.408-3.893c0-3.388,2.716-5.432,6.188-5.432c4.116,0,6.3,2.436,6.3,5.18
+			c0,1.708-0.7,3.164-2.296,4.004c1.903,0.952,2.968,2.212,2.968,4.788C23.168,22.792,21.544,26.712,16.28,26.712z M16.224,17.332
+			c-1.428,0-2.8,0.924-2.8,3.08c0,1.903,1.092,3.164,2.884,3.164c2.043,0,2.829-1.765,2.829-3.137
+			C19.137,19.04,18.408,17.332,16.224,17.332z M18.744,11.899c0-1.512-1.036-2.464-2.296-2.464c-1.764,0-2.688,1.008-2.688,2.464
+			c0,1.177,0.868,2.464,2.548,2.464C17.848,14.363,18.744,13.328,18.744,11.899z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/9.gif b/org.apache.click.eclipse/documentation/user-guide/images/callouts/9.gif
new file mode 100644
index 0000000..da12a4f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/9.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/9.png b/org.apache.click.eclipse/documentation/user-guide/images/callouts/9.png
new file mode 100644
index 0000000..a0676d2
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/9.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/callouts/9.svg b/org.apache.click.eclipse/documentation/user-guide/images/callouts/9.svg
new file mode 100644
index 0000000..bc149d3
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/callouts/9.svg
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.0" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="33" height="33" viewBox="0 0 33 33"
+	 style="overflow:visible;enable-background:new 0 0 33 33;" xml:space="preserve">
+<circle style="stroke:#000000;" cx="16.5" cy="16.5" r="16"/>
+<g>
+	<g style="enable-background:new    ;">
+		<path style="fill:#FFFFFF;" d="M13.953,21.921v0.027c0.224,1.372,1.092,1.961,2.296,1.961c1.624,0,3.248-1.372,3.276-5.545
+			l-0.057-0.056c-0.896,1.344-2.436,1.68-3.78,1.68c-3.808,0-6.02-2.884-6.02-6.216c0-4.872,2.884-7.14,6.776-7.14
+			c6.888,0,7,7.42,7,10.22c0,7.7-3.641,10.192-7.224,10.192c-3.388,0-5.824-1.96-6.16-5.124H13.953z M16.529,16.853
+			c1.372,0,2.884-0.979,2.884-3.332c0-2.268-0.98-3.668-2.996-3.668c-1.008,0-2.828,0.504-2.828,3.36
+			C13.589,16.209,15.045,16.853,16.529,16.853z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/caution.gif b/org.apache.click.eclipse/documentation/user-guide/images/caution.gif
new file mode 100644
index 0000000..d9f5e5b
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/caution.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/caution.png b/org.apache.click.eclipse/documentation/user-guide/images/caution.png
new file mode 100644
index 0000000..5b7809c
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/caution.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/caution.svg b/org.apache.click.eclipse/documentation/user-guide/images/caution.svg
new file mode 100644
index 0000000..dd84f3f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/caution.svg
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In  -->
+<!DOCTYPE svg [
+	<!ENTITY st0 "fill:#FFFFFF;stroke:none;">
+	<!ENTITY st1 "fill:#FFFFFF;stroke-width:6.6112;stroke-linecap:round;stroke-linejoin:round;">
+	<!ENTITY st2 "stroke:#FFFFFF;stroke-width:6.6112;">
+	<!ENTITY st3 "fill:none;stroke:none;">
+	<!ENTITY st4 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
+	<!ENTITY st5 "stroke:none;">
+]>
+<svg  width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
+	<g id="Layer_x0020_3" style="&st4;">
+		<g>
+			<path style="&st2;" d="M41.7,35.3L26.6,9.4c-0.6-1-1.7-1.7-2.9-1.6c-1.2,0-2.3,0.7-2.9,1.7L6.3,35.4c-0.6,1-0.6,2.3,0,3.3c0.6,1,1.7,1.6,2.9,1.6h29.6c1.2,0,2.3-0.6,2.9-1.7c0.6-1,0.6-2.3,0-3.3z"/>
+			<path style="&st1;" d="M23.7,11L9.2,37h29.6L23.7,11z"/>
+			<path style="&st0;" d="M23.7,11.9L10.3,36.1h27.5l-14-24.1z"/>
+			<g>
+				<path style="&st5;" d="M24.1,34c-1.1,0-1.8-0.8-1.8-1.8c0-1.1,0.7-1.8,1.8-1.8c1.1,0,1.8,0.7,1.8,1.8c0,1-0.7,1.8-1.8,1.8h0z M22.9,29.3l-0.4-9.1h3.2l-0.4,9.1h-2.3z"/>
+			</g>
+		</g>
+	</g>
+	<g id="crop_x0020_marks" style="&st4;">
+		<path style="&st3;" d="M48,48H0V0h48v48z"/>
+	</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/caution.tif b/org.apache.click.eclipse/documentation/user-guide/images/caution.tif
new file mode 100644
index 0000000..4a28294
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/caution.tif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/click-logo.png b/org.apache.click.eclipse/documentation/user-guide/images/click-logo.png
new file mode 100644
index 0000000..07c6bb2
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/click-logo.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/caution.svg b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/caution.svg
new file mode 100644
index 0000000..7a0db0b
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/caution.svg
@@ -0,0 +1,141 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.1" id="caution" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="48" height="48" viewBox="0 0 48 48"
+	 overflow="visible" enable-background="new 0 0 48 48" xml:space="preserve">
+<g>
+	<g>
+		<g>
+			<path stroke="#FFFFFF" stroke-width="6.6112" d="M41.629,36.303L26.527,10.403c-0.602-1-1.698-1.7-2.898-1.6
+				c-1.2,0-2.3,0.7-2.9,1.7l-14.5,25.899c-0.6,1-0.6,2.301,0,3.301s1.7,1.6,2.9,1.6h29.599c1.199,0,2.301-0.6,2.899-1.699
+				C42.229,38.604,42.229,37.303,41.629,36.303L41.629,36.303z"/>
+			<g>
+				<path fill="#FFFFFF" stroke="#FFCC00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" d="M23.581,12.003
+					l-14.5,26H38.68L23.581,12.003z"/>
+				<polygon fill="#FFFFFF" stroke="#FFCD00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.582,12.054 9.137,37.953 38.622,37.953 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFCE00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.583,12.104 9.193,37.9 38.566,37.9 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFCF00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.583,12.153 9.25,37.854 38.508,37.854 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFD000" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.584,12.205 9.309,37.805 38.451,37.805 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFD100" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.585,12.253 9.364,37.753 38.395,37.753 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFD200" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.586,12.304 9.421,37.703 38.337,37.703 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFD300" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.587,12.354 9.479,37.652 38.279,37.652 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFD400" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.588,12.403 9.537,37.604 38.223,37.604 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFD500" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.589,12.455 9.591,37.553 38.166,37.553 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFD600" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.591,12.503 9.649,37.503 38.109,37.503 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFD700" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.591,12.554 9.707,37.453 38.053,37.453 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFD800" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.593,12.604 9.764,37.402 37.996,37.402 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFD900" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.594,12.653 9.819,37.354 37.939,37.354 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFDA00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.596,12.705 9.876,37.303 37.882,37.303 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFDB00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.597,12.753 9.935,37.253 37.824,37.253 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFDC00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.599,12.804 9.991,37.203 37.768,37.203 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFDD00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.601,12.854 10.047,37.152 37.711,37.152 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFDE00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.602,12.903 10.104,37.104 37.654,37.104 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFDF00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.603,12.955 10.163,37.053 37.598,37.053 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFE000" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.604,13.003 10.218,37.003 37.54,37.003 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFE100" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.604,13.054 10.275,36.953 37.482,36.953 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFE200" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.605,13.104 10.333,36.902 37.427,36.902 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFE300" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.606,13.153 10.389,36.854 37.37,36.854 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFE400" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.607,13.205 10.445,36.805 37.312,36.805 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFE500" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.608,13.253 10.502,36.753 37.256,36.753 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFE600" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.609,13.304 10.561,36.703 37.197,36.703 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFE600" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.61,13.354 10.617,36.652 37.143,36.652 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFE700" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.611,13.403 10.673,36.604 37.085,36.604 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFE800" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.613,13.455 10.73,36.553 37.027,36.553 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFE900" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.614,13.503 10.789,36.503 36.971,36.503 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFEA00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.616,13.554 10.844,36.453 36.914,36.453 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFEB00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.617,13.604 10.901,36.402 36.857,36.402 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFEC00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.618,13.653 10.958,36.354 36.8,36.354 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFED00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.619,13.705 11.017,36.303 36.742,36.303 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFEE00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.622,13.753 11.071,36.253 36.688,36.253 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFEF00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.623,13.804 11.129,36.203 36.63,36.203 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFF000" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.624,13.854 11.188,36.152 36.572,36.152 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFF100" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.625,13.903 11.243,36.104 36.516,36.104 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFF200" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.625,13.955 11.299,36.053 36.459,36.053 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFF300" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.626,14.003 11.356,36.003 36.4,36.003 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFF400" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.627,14.054 11.415,35.953 36.346,35.953 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFF500" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.628,14.104 11.471,35.902 36.288,35.902 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFF600" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.629,14.153 11.527,35.854 36.232,35.854 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFF700" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.63,14.205 11.584,35.805 36.174,35.805 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFF800" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.631,14.253 11.643,35.753 36.117,35.753 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFF900" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.632,14.304 11.699,35.703 36.061,35.703 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFFA00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.633,14.354 11.754,35.652 36.003,35.652 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFFB00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.635,14.403 11.812,35.604 35.945,35.604 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFFC00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.637,14.455 11.869,35.555 35.891,35.555 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFFD00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.638,14.503 11.925,35.503 35.833,35.503 				"/>
+				<polygon fill="#FFFFFF" stroke="#FFFE00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+					23.639,14.554 11.982,35.453 35.775,35.453 				"/>
+				<path fill="#FFFFFF" stroke="#FFFF00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" d="M23.64,14.604
+					l-11.6,20.8h23.678L23.64,14.604z"/>
+			</g>
+		</g>
+		
+			<linearGradient id="XMLID_50_" gradientUnits="userSpaceOnUse" x1="395.8457" y1="758.1504" x2="395.8457" y2="785.7822" gradientTransform="matrix(1 0 0 1 -372 -747)">
+			<stop  offset="0" style="stop-color:#FFFFFF"/>
+			<stop  offset="1" style="stop-color:#FFFF00"/>
+		</linearGradient>
+		<path fill="url(#XMLID_50_)" d="M38.891,34.532L26.055,12.519c-0.511-0.85-1.443-1.445-2.462-1.36
+			c-1.02,0-1.955,0.595-2.465,1.445L8.8,34.617c-0.51,0.851-0.51,1.953,0,2.805c0.51,0.852,1.445,1.36,2.465,1.36h25.158
+			c1.021,0,1.956-0.511,2.467-1.445C39.4,36.484,39.4,35.382,38.891,34.532L38.891,34.532z"/>
+	</g>
+	<g>
+		<path d="M23.929,33.948c-1.1,0-1.8-0.8-1.8-1.8c0-1.102,0.7-1.801,1.8-1.801c1.101,0,1.8,0.699,1.8,1.801
+			C25.729,33.148,25.029,33.948,23.929,33.948L23.929,33.948z M22.729,29.248l-0.4-9.1h3.2l-0.399,9.1h-2.297H22.729z"/>
+	</g>
+</g>
+<g id="crop_x0020_marks">
+	<path fill="none" d="M47.93,49.049H-0.071v-48H47.93V49.049z"/>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/home.svg b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/home.svg
new file mode 100644
index 0000000..d6dbc01
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/home.svg
@@ -0,0 +1,498 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="48" height="48" viewBox="0 0 48 48"
+	 overflow="visible" enable-background="new 0 0 48 48" xml:space="preserve">
+<g id="Home">
+	<g>
+		<g id="Chimney">
+			<g>
+				<path fill="#660000" d="M30.417,17.563c2.776,2.348,8.258,0.835,7.742,0.434c0-1.2,0-6.9,0-6.9c0-1.2-0.802-2-2-2h-4.802
+					c-1,0-1.698,0.6-1.899,1.5C28.648,9.916,28.359,15.822,30.417,17.563z"/>
+				<path fill="#670000" d="M30.422,17.556c2.771,2.343,8.244,0.833,7.729,0.433c0-1.199,0-6.889,0-6.889
+					c0-1.198-0.799-1.997-1.996-1.997h-4.793c-0.998,0-1.695,0.599-1.896,1.498C28.657,9.921,28.368,15.818,30.422,17.556z"/>
+				<path fill="#680000" d="M30.428,17.548c2.768,2.34,8.229,0.832,7.717,0.432c0-1.196,0-6.876,0-6.876
+					c0-1.196-0.799-1.993-1.994-1.993h-4.783c-0.997,0-1.693,0.598-1.895,1.495C28.665,9.927,28.377,15.813,30.428,17.548z"/>
+				<path fill="#690000" d="M30.434,17.541c2.762,2.336,8.215,0.831,7.703,0.432c0-1.194,0-6.865,0-6.865
+					c0-1.194-0.798-1.989-1.99-1.989H31.37c-0.994,0-1.69,0.596-1.892,1.492C28.674,9.932,28.387,15.809,30.434,17.541z"/>
+				<path fill="#6B0000" d="M30.438,17.533c2.758,2.332,8.203,0.829,7.69,0.431c0-1.192,0-6.853,0-6.853
+					c0-1.192-0.796-1.987-1.987-1.987h-4.768c-0.993,0-1.688,0.596-1.889,1.49C28.682,9.937,28.395,15.804,30.438,17.533z"/>
+				<path fill="#6C0000" d="M30.443,17.525c2.752,2.328,8.188,0.828,7.677,0.43c0-1.19,0-6.841,0-6.841
+					c0-1.19-0.795-1.983-1.983-1.983h-4.76c-0.99,0-1.686,0.595-1.885,1.487C28.689,9.943,28.402,15.799,30.443,17.525z"/>
+				<path fill="#6D0000" d="M30.448,17.518c2.747,2.323,8.174,0.826,7.663,0.429c0-1.188,0-6.829,0-6.829
+					c0-1.188-0.793-1.979-1.979-1.979h-4.751c-0.99,0-1.682,0.593-1.881,1.485C28.698,9.949,28.412,15.795,30.448,17.518z"/>
+				<path fill="#6E0000" d="M30.454,17.51c2.743,2.32,8.159,0.825,7.649,0.429c0-1.187,0-6.818,0-6.818
+					c0-1.186-0.791-1.976-1.977-1.976h-4.744c-0.986,0-1.679,0.592-1.877,1.482C28.707,9.954,28.421,15.791,30.454,17.51z"/>
+				<path fill="#6F0000" d="M30.46,17.503c2.738,2.315,8.146,0.824,7.636,0.427c0-1.184,0-6.806,0-6.806
+					c0-1.184-0.789-1.973-1.972-1.973h-4.735c-0.986,0-1.677,0.592-1.875,1.479C28.715,9.96,28.43,15.786,30.46,17.503z"/>
+				<path fill="#700000" d="M30.465,17.495c2.733,2.312,8.131,0.822,7.623,0.427c0-1.182,0-6.794,0-6.794
+					c0-1.182-0.789-1.969-1.969-1.969h-4.729c-0.983,0-1.673,0.59-1.871,1.477C28.725,9.965,28.438,15.781,30.465,17.495z"/>
+				<path fill="#720000" d="M30.471,17.487c2.729,2.308,8.116,0.821,7.609,0.426c0-1.18,0-6.782,0-6.782
+					c0-1.179-0.787-1.966-1.967-1.966h-4.719c-0.982,0-1.67,0.589-1.867,1.475C28.73,9.97,28.447,15.776,30.471,17.487z"/>
+				<path fill="#730000" d="M30.477,17.48c2.724,2.304,8.103,0.819,7.597,0.426c0-1.178,0-6.771,0-6.771
+					c0-1.177-0.786-1.962-1.962-1.962H31.4c-0.981,0-1.668,0.589-1.865,1.472C28.74,9.976,28.456,15.772,30.477,17.48z"/>
+				<path fill="#740000" d="M30.48,17.473c2.72,2.299,8.088,0.817,7.584,0.424c0-1.176,0-6.759,0-6.759
+					c0-1.175-0.785-1.959-1.959-1.959h-4.703c-0.979,0-1.664,0.587-1.861,1.469C28.748,9.981,28.465,15.767,30.48,17.473z"/>
+				<path fill="#750000" d="M30.484,17.465c2.717,2.295,8.076,0.816,7.572,0.424c0-1.174,0-6.747,0-6.747
+					c0-1.174-0.783-1.956-1.957-1.956h-4.693c-0.979,0-1.661,0.586-1.858,1.467C28.757,9.987,28.475,15.763,30.484,17.465z"/>
+				<path fill="#760000" d="M30.491,17.458c2.71,2.292,8.061,0.815,7.558,0.423c0-1.172,0-6.735,0-6.735
+					c0-1.171-0.781-1.953-1.953-1.953H31.41c-0.977,0-1.658,0.585-1.854,1.465C28.766,9.993,28.482,15.758,30.491,17.458z"/>
+				<path fill="#770000" d="M30.496,17.45c2.706,2.288,8.047,0.813,7.545,0.422c0-1.17,0-6.724,0-6.724
+					c0-1.169-0.781-1.949-1.949-1.949h-4.678c-0.975,0-1.656,0.584-1.854,1.461C28.773,9.998,28.491,15.754,30.496,17.45z"/>
+				<path fill="#790000" d="M30.502,17.442c2.701,2.284,8.032,0.812,7.531,0.422c0-1.167,0-6.712,0-6.712
+					c0-1.167-0.779-1.945-1.945-1.945h-4.671c-0.972,0-1.651,0.583-1.849,1.458C28.781,10.004,28.5,15.749,30.502,17.442z"/>
+				<path fill="#7A0000" d="M30.507,17.435c2.696,2.28,8.019,0.811,7.519,0.421c0-1.166,0-6.7,0-6.7
+					c0-1.166-0.777-1.942-1.942-1.942h-4.661c-0.971,0-1.648,0.583-1.845,1.457C28.79,10.009,28.509,15.745,30.507,17.435z"/>
+				<path fill="#7B0000" d="M30.514,17.427c2.689,2.276,8.004,0.81,7.504,0.42c0-1.164,0-6.688,0-6.688
+					c0-1.163-0.776-1.938-1.938-1.938h-4.653c-0.97,0-1.646,0.582-1.842,1.454C28.798,10.014,28.518,15.74,30.514,17.427z"/>
+				<path fill="#7C0000" d="M30.518,17.42c2.688,2.271,7.99,0.808,7.491,0.419c0-1.162,0-6.677,0-6.677
+					c0-1.161-0.774-1.935-1.935-1.935h-4.646c-0.968,0-1.645,0.58-1.839,1.451C28.807,10.02,28.525,15.736,30.518,17.42z"/>
+				<path fill="#7D0000" d="M30.521,17.412c2.683,2.268,7.978,0.806,7.479,0.418c0-1.159,0-6.665,0-6.665
+					c0-1.159-0.774-1.932-1.933-1.932h-4.637c-0.967,0-1.642,0.58-1.836,1.449C28.814,10.025,28.535,15.73,30.521,17.412z"/>
+				<path fill="#7E0000" d="M30.527,17.404c2.678,2.264,7.963,0.805,7.466,0.418c0-1.157,0-6.652,0-6.652
+					c0-1.158-0.772-1.929-1.929-1.929h-4.629c-0.965,0-1.639,0.578-1.832,1.446C28.823,10.031,28.544,15.726,30.527,17.404z"/>
+				<path fill="#800000" d="M30.533,17.397c2.673,2.26,7.947,0.804,7.451,0.417c0-1.155,0-6.641,0-6.641
+					c0-1.155-0.771-1.925-1.924-1.925h-4.621c-0.963,0-1.635,0.577-1.83,1.443C28.831,10.037,28.553,15.722,30.533,17.397z"/>
+				<path fill="#810000" d="M30.538,17.39c2.668,2.255,7.935,0.802,7.438,0.417c0-1.153,0-6.629,0-6.629
+					c0-1.153-0.77-1.922-1.922-1.922h-4.611c-0.961,0-1.633,0.576-1.826,1.442C28.84,10.042,28.562,15.717,30.538,17.39z"/>
+				<path fill="#820000" d="M30.544,17.382c2.663,2.252,7.92,0.801,7.427,0.416c0-1.151,0-6.618,0-6.618
+					c0-1.151-0.77-1.918-1.92-1.918h-4.604c-0.961,0-1.631,0.575-1.823,1.438C28.85,10.047,28.57,15.713,30.544,17.382z"/>
+				<path fill="#830000" d="M30.549,17.375c2.659,2.248,7.906,0.799,7.413,0.415c0-1.149,0-6.606,0-6.606
+					c0-1.149-0.769-1.915-1.915-1.915H31.45c-0.957,0-1.626,0.574-1.819,1.436C28.855,10.053,28.579,15.708,30.549,17.375z"/>
+				<path fill="#840000" d="M30.555,17.367c2.653,2.243,7.893,0.797,7.399,0.414c0-1.147,0-6.594,0-6.594
+					c0-1.147-0.767-1.911-1.912-1.911h-4.588c-0.955,0-1.623,0.573-1.815,1.434C28.865,10.059,28.588,15.704,30.555,17.367z"/>
+				<path fill="#850000" d="M30.561,17.359c2.648,2.24,7.877,0.797,7.387,0.414c0-1.145,0-6.583,0-6.583
+					c0-1.145-0.766-1.908-1.908-1.908h-4.58c-0.954,0-1.621,0.572-1.812,1.431C28.873,10.064,28.598,15.699,30.561,17.359z"/>
+				<path fill="#860000" d="M30.564,17.352c2.645,2.235,7.863,0.795,7.373,0.413c0-1.143,0-6.57,0-6.57
+					c0-1.143-0.764-1.905-1.904-1.905h-4.571c-0.953,0-1.618,0.571-1.81,1.428C28.882,10.069,28.605,15.694,30.564,17.352z"/>
+				<path fill="#880000" d="M30.57,17.344c2.64,2.232,7.85,0.794,7.359,0.412c0-1.141,0-6.559,0-6.559
+					c0-1.141-0.762-1.901-1.902-1.901h-4.562c-0.949,0-1.613,0.57-1.806,1.426C28.891,10.075,28.613,15.689,30.57,17.344z"/>
+				<path fill="#890000" d="M30.576,17.337c2.634,2.228,7.835,0.792,7.346,0.411c0-1.139,0-6.547,0-6.547
+					c0-1.139-0.76-1.898-1.896-1.898h-4.557c-0.947,0-1.611,0.569-1.803,1.423C28.898,10.08,28.623,15.685,30.576,17.337z"/>
+				<path fill="#8A0000" d="M30.581,17.33c2.63,2.223,7.821,0.79,7.333,0.41c0-1.137,0-6.535,0-6.535
+					c0-1.137-0.76-1.894-1.895-1.894h-4.547c-0.947,0-1.609,0.567-1.801,1.421C28.906,10.086,28.632,15.681,30.581,17.33z"/>
+				<path fill="#8B0000" d="M30.587,17.321c2.625,2.22,7.808,0.79,7.319,0.41c0-1.135,0-6.523,0-6.523
+					c0-1.135-0.758-1.891-1.891-1.891h-4.539c-0.945,0-1.606,0.567-1.797,1.418C28.915,10.091,28.641,15.676,30.587,17.321z"/>
+				<path fill="#8C0000" d="M30.592,17.314c2.62,2.216,7.793,0.788,7.307,0.409c0-1.132,0-6.512,0-6.512
+					c0-1.132-0.756-1.887-1.887-1.887H31.48c-0.943,0-1.604,0.566-1.793,1.416C28.923,10.097,28.648,15.671,30.592,17.314z"/>
+				<path fill="#8D0000" d="M30.598,17.307c2.614,2.211,7.778,0.787,7.293,0.409c0-1.131,0-6.5,0-6.5
+					c0-1.13-0.754-1.884-1.884-1.884h-4.522c-0.941,0-1.601,0.564-1.791,1.413C28.932,10.103,28.658,15.667,30.598,17.307z"/>
+				<path fill="#8F0000" d="M30.604,17.299c2.609,2.208,7.765,0.785,7.279,0.408c0-1.128,0-6.488,0-6.488
+					c0-1.128-0.753-1.881-1.881-1.881h-4.516c-0.939,0-1.598,0.564-1.786,1.411C28.939,10.107,28.668,15.662,30.604,17.299z"/>
+				<path fill="#900000" d="M30.607,17.292c2.605,2.204,7.75,0.784,7.268,0.407c0-1.127,0-6.477,0-6.477
+					c0-1.127-0.753-1.877-1.878-1.877h-4.506c-0.938,0-1.595,0.563-1.783,1.408C28.948,10.113,28.676,15.658,30.607,17.292z"/>
+				<path fill="#910000" d="M30.611,17.284c2.604,2.199,7.738,0.782,7.256,0.406c0-1.124,0-6.464,0-6.464
+					c0-1.125-0.751-1.874-1.874-1.874h-4.498c-0.938,0-1.593,0.562-1.781,1.405C28.956,10.119,28.686,15.653,30.611,17.284z"/>
+				<path fill="#920000" d="M30.618,17.276c2.597,2.196,7.723,0.781,7.241,0.406c0-1.123,0-6.453,0-6.453
+					c0-1.123-0.75-1.871-1.871-1.871h-4.49c-0.936,0-1.588,0.561-1.775,1.403C28.965,10.124,28.693,15.649,30.618,17.276z"/>
+				<path fill="#930000" d="M30.623,17.269c2.592,2.191,7.709,0.779,7.229,0.404c0-1.12,0-6.441,0-6.441
+					c0-1.121-0.748-1.867-1.867-1.867h-4.481c-0.935,0-1.586,0.56-1.772,1.4C28.973,10.13,28.703,15.644,30.623,17.269z"/>
+				<path fill="#940000" d="M30.629,17.261c2.587,2.188,7.694,0.778,7.214,0.404c0-1.119,0-6.43,0-6.43
+					c0-1.119-0.745-1.863-1.862-1.863h-4.475c-0.932,0-1.583,0.559-1.771,1.397C28.98,10.135,28.711,15.64,30.629,17.261z"/>
+				<path fill="#960000" d="M30.634,17.254c2.583,2.184,7.681,0.776,7.201,0.403c0-1.116,0-6.417,0-6.417
+					c0-1.116-0.745-1.86-1.86-1.86H31.51c-0.93,0-1.58,0.558-1.768,1.395C28.988,10.141,28.721,15.635,30.634,17.254z"/>
+				<path fill="#970000" d="M30.641,17.247c2.576,2.179,7.666,0.775,7.188,0.402c0-1.115,0-6.406,0-6.406
+					c0-1.114-0.744-1.856-1.855-1.856h-4.459c-0.928,0-1.576,0.557-1.764,1.393C28.998,10.146,28.729,15.63,30.641,17.247z"/>
+				<path fill="#980000" d="M30.645,17.239c2.573,2.176,7.652,0.774,7.176,0.401c0-1.112,0-6.394,0-6.394
+					c0-1.112-0.742-1.853-1.854-1.853h-4.448c-0.928,0-1.574,0.556-1.762,1.39C29.006,10.151,28.738,15.625,30.645,17.239z"/>
+				<path fill="#990000" d="M30.65,17.231c2.567,2.172,7.638,0.772,7.16,0.401c0-1.11,0-6.383,0-6.383c0-1.11-0.74-1.85-1.85-1.85
+					H31.52c-0.924,0-1.57,0.555-1.758,1.387C29.016,10.157,28.747,15.621,30.65,17.231z"/>
+				<path fill="#9A0000" d="M30.654,17.224c2.563,2.167,7.625,0.771,7.148,0.4c0-1.108,0-6.371,0-6.371
+					c0-1.108-0.74-1.846-1.847-1.846h-4.433c-0.924,0-1.568,0.554-1.756,1.385C29.021,10.163,28.755,15.616,30.654,17.224z"/>
+				<path fill="#9B0000" d="M30.66,17.216c2.561,2.164,7.609,0.769,7.136,0.399c0-1.106,0-6.359,0-6.359
+					c0-1.106-0.737-1.843-1.844-1.843h-4.425c-0.922,0-1.564,0.553-1.752,1.382C29.031,10.168,28.766,15.612,30.66,17.216z"/>
+				<path fill="#9C0000" d="M30.666,17.209c2.555,2.16,7.596,0.768,7.122,0.399c0-1.104,0-6.347,0-6.347
+					c0-1.104-0.737-1.84-1.84-1.84h-4.417c-0.92,0-1.562,0.552-1.748,1.38C29.039,10.174,28.771,15.607,30.666,17.209z"/>
+				<path fill="#9E0000" d="M30.671,17.201c2.55,2.155,7.582,0.767,7.108,0.398c0-1.102,0-6.335,0-6.335
+					c0-1.102-0.735-1.836-1.836-1.836h-4.408c-0.918,0-1.561,0.551-1.745,1.377C29.048,10.179,28.782,15.603,30.671,17.201z"/>
+				<path fill="#9F0000" d="M30.677,17.193c2.544,2.152,7.567,0.765,7.097,0.397c0-1.1,0-6.324,0-6.324
+					c0-1.1-0.735-1.833-1.834-1.833H31.54c-0.916,0-1.558,0.549-1.741,1.375C29.057,10.185,28.79,15.598,30.677,17.193z"/>
+				<path fill="#A00000" d="M30.682,17.186c2.541,2.147,7.555,0.764,7.082,0.396c0-1.098,0-6.312,0-6.312
+					c0-1.098-0.731-1.829-1.828-1.829h-4.393c-0.915,0-1.555,0.548-1.738,1.372C29.064,10.19,28.8,15.594,30.682,17.186z"/>
+				<path fill="#A10000" d="M30.688,17.178c2.535,2.144,7.539,0.763,7.068,0.396c0-1.096,0-6.3,0-6.3
+					c0-1.096-0.73-1.826-1.826-1.826h-4.384c-0.912,0-1.551,0.547-1.733,1.37C29.072,10.196,28.809,15.589,30.688,17.178z"/>
+				<path fill="#A20000" d="M30.691,17.171c2.531,2.14,7.525,0.761,7.057,0.395c0-1.094,0-6.289,0-6.289
+					c0-1.093-0.73-1.822-1.822-1.822H31.55c-0.911,0-1.548,0.546-1.731,1.367C29.081,10.201,28.816,15.584,30.691,17.171z"/>
+				<path fill="#A30000" d="M30.697,17.163c2.525,2.136,7.512,0.76,7.043,0.395c0-1.092,0-6.277,0-6.277
+					c0-1.091-0.729-1.819-1.819-1.819h-4.366c-0.91,0-1.546,0.545-1.729,1.365C29.089,10.207,28.825,15.58,30.697,17.163z"/>
+				<path fill="#A50000" d="M30.703,17.156c2.521,2.132,7.497,0.758,7.029,0.394c0-1.09,0-6.265,0-6.265
+					c0-1.09-0.729-1.816-1.815-1.816h-4.358c-0.908,0-1.543,0.544-1.727,1.362C29.098,10.212,28.835,15.575,30.703,17.156z"/>
+				<path fill="#A60000" d="M30.708,17.148c2.517,2.127,7.483,0.756,7.017,0.393c0-1.087,0-6.253,0-6.253
+					c0-1.088-0.727-1.812-1.812-1.812h-4.351c-0.906,0-1.541,0.543-1.724,1.359C29.105,10.218,28.844,15.571,30.708,17.148z"/>
+				<path fill="#A70000" d="M30.714,17.141c2.511,2.124,7.47,0.755,7.003,0.392c0-1.086,0-6.241,0-6.241
+					c0-1.085-0.725-1.809-1.81-1.809h-4.343c-0.904,0-1.537,0.542-1.719,1.357C29.113,10.223,28.854,15.566,30.714,17.141z"/>
+				<path fill="#A80000" d="M30.719,17.133c2.508,2.12,7.455,0.753,6.99,0.391c0-1.083,0-6.229,0-6.229
+					c0-1.083-0.725-1.806-1.807-1.806h-4.334c-0.902,0-1.533,0.542-1.717,1.354C29.122,10.229,28.861,15.562,30.719,17.133z"/>
+				<path fill="#A90000" d="M30.725,17.125c2.502,2.116,7.44,0.752,6.978,0.391c0-1.082,0-6.218,0-6.218
+					c0-1.081-0.724-1.802-1.804-1.802h-4.325c-0.901,0-1.53,0.54-1.714,1.352C29.131,10.234,28.87,15.557,30.725,17.125z"/>
+				<path fill="#AA0000" d="M30.729,17.118c2.498,2.111,7.428,0.75,6.965,0.39c0-1.08,0-6.206,0-6.206
+					c0-1.079-0.721-1.798-1.799-1.798h-4.318c-0.899,0-1.528,0.539-1.71,1.349C29.139,10.24,28.879,15.552,30.729,17.118z"/>
+				<path fill="#AC0000" d="M30.734,17.11c2.492,2.108,7.412,0.75,6.951,0.389c0-1.078,0-6.194,0-6.194
+					c0-1.077-0.721-1.795-1.797-1.795h-4.311c-0.896,0-1.523,0.538-1.705,1.346C29.146,10.245,28.889,15.548,30.734,17.11z"/>
+				<path fill="#AD0000" d="M30.74,17.103c2.486,2.104,7.398,0.748,6.937,0.389c0-1.076,0-6.183,0-6.183
+					c0-1.075-0.718-1.792-1.792-1.792h-4.302c-0.896,0-1.521,0.537-1.702,1.344C29.154,10.251,28.896,15.543,30.74,17.103z"/>
+				<path fill="#AE0000" d="M30.745,17.096c2.483,2.1,7.385,0.746,6.924,0.388c0-1.074,0-6.171,0-6.171
+					c0-1.073-0.717-1.789-1.788-1.789h-4.294c-0.896,0-1.519,0.537-1.698,1.341C29.164,10.256,28.904,15.539,30.745,17.096z"/>
+				<path fill="#AF0000" d="M30.751,17.088c2.478,2.096,7.37,0.745,6.91,0.387c0-1.072,0-6.159,0-6.159
+					c0-1.071-0.716-1.785-1.785-1.785h-4.285c-0.893,0-1.517,0.535-1.696,1.339C29.172,10.262,28.914,15.534,30.751,17.088z"/>
+				<path fill="#B00000" d="M30.756,17.08c2.475,2.092,7.355,0.744,6.896,0.387c0-1.07,0-6.147,0-6.147
+					c0-1.069-0.713-1.782-1.781-1.782h-4.277c-0.891,0-1.513,0.535-1.691,1.336C29.182,10.267,28.923,15.53,30.756,17.08z"/>
+				<path fill="#B10000" d="M30.762,17.073c2.469,2.088,7.342,0.743,6.885,0.386c0-1.067,0-6.136,0-6.136
+					c0-1.067-0.713-1.778-1.778-1.778h-4.271c-0.889,0-1.51,0.533-1.688,1.334C29.188,10.272,28.932,15.525,30.762,17.073z"/>
+				<path fill="#B30000" d="M30.768,17.065c2.463,2.083,7.328,0.741,6.871,0.385c0-1.065,0-6.124,0-6.124
+					c0-1.065-0.712-1.775-1.775-1.775h-4.262c-0.887,0-1.506,0.532-1.687,1.332C29.197,10.278,28.939,15.521,30.768,17.065z"/>
+				<path fill="#B40000" d="M30.771,17.058c2.459,2.08,7.313,0.74,6.857,0.384c0-1.063,0-6.112,0-6.112
+					c0-1.063-0.71-1.771-1.771-1.771h-4.252c-0.887,0-1.506,0.531-1.685,1.329C29.205,10.284,28.949,15.516,30.771,17.058z"/>
+				<path fill="#B50000" d="M30.777,17.05c2.453,2.076,7.3,0.738,6.845,0.383c0-1.062,0-6.101,0-6.101
+					c0-1.061-0.709-1.768-1.769-1.768h-4.244c-0.885,0-1.502,0.53-1.682,1.326C29.214,10.289,28.958,15.511,30.777,17.05z"/>
+				<path fill="#B60000" d="M30.782,17.043c2.45,2.071,7.286,0.736,6.831,0.382c0-1.059,0-6.088,0-6.088
+					c0-1.059-0.707-1.765-1.766-1.765h-4.236c-0.881,0-1.498,0.529-1.676,1.323C29.223,10.294,28.967,15.507,30.782,17.043z"/>
+				<path fill="#B70000" d="M30.787,17.035c2.445,2.067,7.271,0.735,6.818,0.382c0-1.057,0-6.077,0-6.077
+					c0-1.057-0.705-1.761-1.762-1.761h-4.229c-0.881,0-1.495,0.528-1.674,1.321C29.23,10.3,28.977,15.502,30.787,17.035z"/>
+				<path fill="#B80000" d="M30.793,17.028c2.439,2.063,7.258,0.733,6.807,0.381c0-1.055,0-6.065,0-6.065
+					c0-1.055-0.705-1.758-1.76-1.758h-4.22c-0.879,0-1.493,0.527-1.67,1.318C29.238,10.306,28.984,15.498,30.793,17.028z"/>
+				<path fill="#B90000" d="M30.798,17.02c2.437,2.06,7.244,0.732,6.792,0.38c0-1.053,0-6.053,0-6.053
+					c0-1.053-0.703-1.754-1.754-1.754h-4.212c-0.877,0-1.49,0.526-1.667,1.316C29.247,10.311,28.993,15.493,30.798,17.02z"/>
+				<path fill="#BB0000" d="M30.805,17.013c2.43,2.056,7.229,0.731,6.777,0.379c0-1.051,0-6.042,0-6.042
+					c0-1.051-0.701-1.751-1.751-1.751h-4.204c-0.875,0-1.486,0.525-1.663,1.313C29.255,10.316,29.002,15.488,30.805,17.013z"/>
+				<path fill="#BC0000" d="M30.809,17.005c2.428,2.052,7.217,0.729,6.767,0.379c0-1.049,0-6.03,0-6.03
+					c0-1.048-0.7-1.748-1.748-1.748h-4.195c-0.873,0-1.483,0.524-1.659,1.311C29.264,10.322,29.012,15.484,30.809,17.005z"/>
+				<path fill="#BD0000" d="M30.814,16.998c2.42,2.047,7.201,0.728,6.752,0.378c0-1.047,0-6.018,0-6.018
+					c0-1.046-0.699-1.744-1.744-1.744h-4.188c-0.872,0-1.481,0.523-1.657,1.309C29.271,10.328,29.02,15.48,30.814,16.998z"/>
+				<path fill="#BE0000" d="M30.818,16.99c2.418,2.044,7.188,0.727,6.74,0.377c0-1.045,0-6.006,0-6.006
+					c0-1.044-0.699-1.74-1.742-1.74h-4.178c-0.871,0-1.479,0.522-1.654,1.305C29.279,10.333,29.027,15.475,30.818,16.99z"/>
+				<path fill="#BF0000" d="M30.824,16.982c2.412,2.04,7.174,0.725,6.727,0.376c0-1.043,0-5.994,0-5.994
+					c0-1.043-0.695-1.737-1.736-1.737h-4.172c-0.869,0-1.476,0.521-1.65,1.303C29.288,10.338,29.037,15.47,30.824,16.982z"/>
+				<path fill="#C00000" d="M30.83,16.975c2.406,2.036,7.158,0.724,6.713,0.376c0-1.041,0-5.982,0-5.982
+					c0-1.041-0.695-1.734-1.734-1.734h-4.162c-0.867,0-1.473,0.52-1.647,1.3C29.297,10.344,29.046,15.466,30.83,16.975z"/>
+				<path fill="#C20000" d="M30.835,16.967c2.403,2.032,7.146,0.722,6.7,0.375c0-1.039,0-5.971,0-5.971
+					c0-1.039-0.694-1.73-1.73-1.73H31.65c-0.865,0-1.471,0.519-1.646,1.298C29.305,10.35,29.055,15.461,30.835,16.967z"/>
+				<path fill="#C30000" d="M30.841,16.96c2.397,2.027,7.132,0.721,6.687,0.375c0-1.037,0-5.959,0-5.959
+					c0-1.037-0.691-1.727-1.728-1.727h-4.146c-0.863,0-1.467,0.518-1.643,1.295C29.312,10.355,29.062,15.457,30.841,16.96z"/>
+				<path fill="#C40000" d="M30.846,16.952c2.395,2.023,7.117,0.72,6.674,0.374c0-1.035,0-5.948,0-5.948
+					c0-1.034-0.69-1.724-1.725-1.724h-4.138c-0.862,0-1.464,0.517-1.64,1.293C29.32,10.36,29.072,15.452,30.846,16.952z"/>
+				<path fill="#C50000" d="M30.852,16.945c2.39,2.02,7.104,0.718,6.66,0.373c0-1.033,0-5.936,0-5.936
+					c0-1.032-0.689-1.72-1.721-1.72H31.66c-0.859,0-1.46,0.516-1.635,1.291C29.33,10.366,29.081,15.447,30.852,16.945z"/>
+				<path fill="#C60000" d="M30.855,16.937c2.385,2.016,7.09,0.717,6.646,0.373c0-1.031,0-5.924,0-5.924
+					c0-1.03-0.688-1.717-1.717-1.717h-4.122c-0.858,0-1.458,0.515-1.631,1.288C29.338,10.372,29.09,15.443,30.855,16.937z"/>
+				<path fill="#C70000" d="M30.861,16.93c2.38,2.012,7.074,0.715,6.634,0.372c0-1.029,0-5.913,0-5.913
+					c0-1.028-0.687-1.713-1.714-1.713h-4.113c-0.855,0-1.455,0.514-1.628,1.285C29.348,10.377,29.1,15.438,30.861,16.93z"/>
+				<path fill="#C90000" d="M30.867,16.922c2.374,2.008,7.061,0.714,6.619,0.371c0-1.027,0-5.9,0-5.9c0-1.026-0.686-1.71-1.709-1.71
+					h-4.105c-0.855,0-1.451,0.513-1.625,1.282C29.354,10.382,29.107,15.434,30.867,16.922z"/>
+				<path fill="#CA0000" d="M30.872,16.915c2.37,2.003,7.047,0.712,6.606,0.37c0-1.024,0-5.889,0-5.889
+					c0-1.024-0.685-1.707-1.707-1.707h-4.098c-0.854,0-1.447,0.512-1.621,1.28C29.363,10.388,29.116,15.429,30.872,16.915z"/>
+				<path fill="#CB0000" d="M30.878,16.907c2.364,2,7.032,0.711,6.595,0.37c0-1.022,0-5.877,0-5.877
+					c0-1.022-0.684-1.703-1.703-1.703h-4.09c-0.853,0-1.447,0.511-1.619,1.277C29.371,10.394,29.125,15.424,30.878,16.907z"/>
+				<path fill="#CC0000" d="M30.883,16.899c2.36,1.996,7.02,0.709,6.581,0.369c0-1.021,0-5.865,0-5.865c0-1.02-0.682-1.7-1.7-1.7
+					h-4.08c-0.851,0-1.443,0.51-1.615,1.275C29.38,10.399,29.134,15.42,30.883,16.899z"/>
+			</g>
+			
+				<linearGradient id="Chimney_Highlight_1_" gradientUnits="userSpaceOnUse" x1="219.5195" y1="-239.7031" x2="219.5195" y2="-247.9902" gradientTransform="matrix(1 0 0 -1 -186 -230)">
+				<stop  offset="0" style="stop-color:#FFFFFF"/>
+				<stop  offset="1" style="stop-color:#CC0000"/>
+			</linearGradient>
+			<path id="Chimney_Highlight" fill="url(#Chimney_Highlight_1_)" d="M30.883,16.899c2.36,1.996,7.02,0.709,6.581,0.369
+				c0-1.021,0-5.865,0-5.865c0-1.02-0.682-1.7-1.7-1.7h-4.08c-0.851,0-1.443,0.51-1.615,1.275
+				C29.38,10.399,29.134,15.42,30.883,16.899z"/>
+		</g>
+		<g id="House">
+			<g>
+				<path fill="#FFCC00" d="M8.5,24.788c0,2.4,0,14.2,0,14.2c0,1.101,0.8,1.9,1.8,1.9h27.4c1.1,0,1.899-0.9,1.899-2
+					c0,0,0-11.8,0-14.2C40.6,24.688,7.4,24.788,8.5,24.788z"/>
+				<path fill="#FFCD00" d="M8.545,24.812c0,2.395,0,14.159,0,14.159c0,1.097,0.798,1.895,1.794,1.895h27.322
+					c1.097,0,1.894-0.897,1.894-1.993c0,0,0-11.767,0-14.16C40.552,24.711,7.448,24.812,8.545,24.812z"/>
+				<path fill="#FFCE00" d="M8.589,24.835c0,2.387,0,14.119,0,14.119c0,1.094,0.795,1.889,1.79,1.889h27.242
+					c1.094,0,1.889-0.896,1.889-1.988c0,0,0-11.73,0-14.118C40.504,24.735,7.496,24.835,8.589,24.835z"/>
+				<path fill="#FFCF00" d="M8.634,24.857c0,2.38,0,14.077,0,14.077c0,1.091,0.793,1.884,1.785,1.884h27.163
+					c1.09,0,1.883-0.894,1.883-1.981c0,0,0-11.698,0-14.078C40.456,24.758,7.543,24.857,8.634,24.857z"/>
+				<path fill="#FFD000" d="M8.68,24.88c0,2.373,0,14.037,0,14.037c0,1.088,0.791,1.879,1.779,1.879h27.084
+					c1.087,0,1.877-0.892,1.877-1.979c0,0,0-11.663,0-14.036C40.409,24.782,7.592,24.88,8.68,24.88z"/>
+				<path fill="#FFD100" d="M8.725,24.903c0,2.366,0,13.995,0,13.995c0,1.085,0.788,1.874,1.773,1.874h27.006
+					c1.083,0,1.872-0.889,1.872-1.973c0,0,0-11.629,0-13.994C40.361,24.806,7.64,24.903,8.725,24.903z"/>
+				<path fill="#FFD200" d="M8.769,24.925c0,2.359,0,13.955,0,13.955c0,1.082,0.786,1.867,1.769,1.867h26.926
+					c1.081,0,1.866-0.884,1.866-1.965c0,0,0-11.596,0-13.953C40.312,24.829,7.688,24.925,8.769,24.925z"/>
+				<path fill="#FFD300" d="M8.814,24.949c0,2.354,0,13.914,0,13.914c0,1.078,0.784,1.861,1.763,1.861h26.848
+					c1.077,0,1.86-0.882,1.86-1.959c0,0,0-11.562,0-13.914C40.266,24.852,7.736,24.949,8.814,24.949z"/>
+				<path fill="#FFD400" d="M8.858,24.973c0,2.345,0,13.872,0,13.872c0,1.074,0.781,1.855,1.758,1.855h26.768
+					c1.074,0,1.854-0.88,1.854-1.953c0,0,0-11.526,0-13.873C40.217,24.876,7.784,24.973,8.858,24.973z"/>
+				<path fill="#FFD500" d="M8.903,24.997c0,2.338,0,13.83,0,13.83c0,1.072,0.779,1.853,1.753,1.853h26.689
+					c1.07,0,1.85-0.877,1.85-1.948c0,0,0-11.493,0-13.832C40.17,24.898,7.832,24.997,8.903,24.997z"/>
+				<path fill="#FFD600" d="M8.949,25.019c0,2.331,0,13.791,0,13.791c0,1.068,0.777,1.846,1.748,1.846h26.61
+					c1.067,0,1.846-0.875,1.846-1.941c0,0,0-11.459,0-13.791C40.122,24.921,7.88,25.019,8.949,25.019z"/>
+				<path fill="#FFD700" d="M8.993,25.042c0,2.324,0,13.75,0,13.75c0,1.064,0.774,1.84,1.743,1.84h26.532
+					c1.064,0,1.838-0.871,1.838-1.937c0,0,0-11.426,0-13.75C40.074,24.945,7.928,25.042,8.993,25.042z"/>
+				<path fill="#FFD800" d="M9.039,25.065c0,2.316,0,13.708,0,13.708c0,1.063,0.772,1.835,1.737,1.835h26.453
+					c1.062,0,1.834-0.869,1.834-1.931c0,0,0-11.392,0-13.71C40.027,24.968,7.977,25.065,9.039,25.065z"/>
+				<path fill="#FFD900" d="M9.083,25.087c0,2.312,0,13.668,0,13.668c0,1.061,0.77,1.83,1.732,1.83h26.373
+					c1.06,0,1.828-0.867,1.828-1.926c0,0,0-11.356,0-13.668C39.979,24.993,8.024,25.087,9.083,25.087z"/>
+				<path fill="#FFDA00" d="M9.128,25.111c0,2.304,0,13.626,0,13.626c0,1.057,0.767,1.824,1.727,1.824h26.293
+					c1.056,0,1.822-0.864,1.822-1.919c0,0,0-11.323,0-13.627C39.932,25.016,8.072,25.111,9.128,25.111z"/>
+				<path fill="#FFDB00" d="M9.172,25.134c0,2.297,0,13.586,0,13.586c0,1.053,0.766,1.818,1.722,1.818h26.215
+					c1.052,0,1.816-0.861,1.816-1.914c0,0,0-11.289,0-13.586C39.884,25.04,8.12,25.134,9.172,25.134z"/>
+				<path fill="#FFDC00" d="M9.217,25.157c0,2.29,0,13.545,0,13.545c0,1.051,0.763,1.812,1.717,1.812H37.07
+					c1.049,0,1.812-0.858,1.812-1.907c0,0,0-11.256,0-13.545C39.836,25.062,8.168,25.157,9.217,25.157z"/>
+				<path fill="#FFDD00" d="M9.263,25.18c0,2.282,0,13.505,0,13.505c0,1.046,0.76,1.807,1.711,1.807h26.055
+					c1.047,0,1.808-0.855,1.808-1.902c0,0,0-11.221,0-13.502C39.788,25.085,8.216,25.18,9.263,25.18z"/>
+				<path fill="#FFDE00" d="M9.307,25.204c0,2.275,0,13.463,0,13.463c0,1.043,0.758,1.801,1.707,1.801h25.978
+					c1.043,0,1.801-0.854,1.801-1.896c0,0,0-11.188,0-13.463C39.74,25.109,8.265,25.204,9.307,25.204z"/>
+				<path fill="#FFDF00" d="M9.352,25.226c0,2.27,0,13.423,0,13.423c0,1.04,0.756,1.796,1.701,1.796h25.899
+					c1.039,0,1.795-0.852,1.795-1.89c0,0,0-11.153,0-13.423C39.691,25.132,8.312,25.226,9.352,25.226z"/>
+				<path fill="#FFE000" d="M9.397,25.251c0,2.262,0,13.379,0,13.379c0,1.037,0.753,1.791,1.696,1.791h25.819
+					c1.036,0,1.79-0.849,1.79-1.883c0,0,0-11.119,0-13.383C39.645,25.155,8.36,25.251,9.397,25.251z"/>
+				<path fill="#FFE100" d="M9.442,25.272c0,2.255,0,13.34,0,13.34c0,1.034,0.751,1.785,1.691,1.785h25.74
+					c1.033,0,1.784-0.846,1.784-1.879c0,0,0-11.084,0-13.34C39.598,25.179,8.408,25.272,9.442,25.272z"/>
+				<path fill="#FFE200" d="M9.486,25.296c0,2.248,0,13.299,0,13.299c0,1.029,0.749,1.779,1.686,1.779h25.662
+					c1.029,0,1.777-0.844,1.777-1.873c0,0,0-11.051,0-13.299C39.549,25.202,8.457,25.296,9.486,25.296z"/>
+				<path fill="#FFE300" d="M9.532,25.318c0,2.241,0,13.259,0,13.259c0,1.027,0.747,1.773,1.68,1.773h25.583
+					c1.025,0,1.771-0.84,1.771-1.866c0,0,0-11.017,0-13.259C39.502,25.226,8.504,25.318,9.532,25.318z"/>
+				<path fill="#FFE400" d="M9.577,25.341c0,2.234,0,13.218,0,13.218c0,1.024,0.744,1.769,1.675,1.769h25.503
+					c1.022,0,1.769-0.838,1.769-1.859c0,0,0-10.983,0-13.219C39.454,25.249,8.553,25.341,9.577,25.341z"/>
+				<path fill="#FFE500" d="M9.621,25.364c0,2.229,0,13.178,0,13.178c0,1.021,0.742,1.763,1.67,1.763h25.424
+					c1.02,0,1.764-0.835,1.764-1.855c0,0,0-10.948,0-13.176C39.406,25.272,8.601,25.364,9.621,25.364z"/>
+				<path fill="#FFE600" d="M9.666,25.388c0,2.221,0,13.135,0,13.135c0,1.02,0.74,1.758,1.665,1.758h25.345
+					c1.018,0,1.758-0.832,1.758-1.85c0,0,0-10.914,0-13.135C39.357,25.296,8.648,25.388,9.666,25.388z"/>
+				<path fill="#FFE600" d="M9.711,25.411c0,2.215,0,13.094,0,13.094c0,1.016,0.737,1.754,1.66,1.754h25.266
+					c1.016,0,1.752-0.83,1.752-1.846c0,0,0-10.879,0-13.094C39.311,25.319,8.696,25.411,9.711,25.411z"/>
+				<path fill="#FFE700" d="M9.756,25.434c0,2.207,0,13.054,0,13.054c0,1.012,0.735,1.747,1.654,1.747h25.188
+					c1.012,0,1.746-0.827,1.746-1.839c0,0,0-10.846,0-13.053C39.264,25.343,8.745,25.434,9.756,25.434z"/>
+				<path fill="#FFE800" d="M9.801,25.458c0,2.199,0,13.013,0,13.013c0,1.008,0.732,1.741,1.649,1.741h25.108
+					c1.008,0,1.74-0.825,1.74-1.834c0,0,0-10.812,0-13.012C39.215,25.366,8.792,25.458,9.801,25.458z"/>
+				<path fill="#FFE900" d="M9.845,25.48c0,2.192,0,12.972,0,12.972c0,1.006,0.73,1.735,1.644,1.735h25.029
+					c1.006,0,1.735-0.822,1.735-1.827c0,0,0-10.777,0-12.971C39.167,25.39,8.84,25.48,9.845,25.48z"/>
+				<path fill="#FFEA00" d="M9.89,25.503c0,2.187,0,12.931,0,12.931c0,1.002,0.729,1.729,1.639,1.729h24.95
+					c1.002,0,1.729-0.818,1.729-1.82c0,0,0-10.744,0-12.93C39.12,25.413,8.889,25.503,9.89,25.503z"/>
+				<path fill="#FFEB00" d="M9.935,25.526c0,2.18,0,12.891,0,12.891c0,0.998,0.726,1.725,1.634,1.725h24.871
+					c1,0,1.726-0.817,1.726-1.814c0,0,0-10.711,0-12.89C39.072,25.437,8.937,25.526,9.935,25.526z"/>
+				<path fill="#FFEC00" d="M9.98,25.548c0,2.174,0,12.85,0,12.85c0,0.996,0.724,1.721,1.628,1.721H36.4
+					c0.994,0,1.719-0.814,1.719-1.811c0,0,0-10.676,0-12.85C39.023,25.46,8.985,25.548,9.98,25.548z"/>
+				<path fill="#FFED00" d="M10.025,25.572c0,2.165,0,12.808,0,12.808c0,0.992,0.721,1.715,1.623,1.715h24.713
+					c0.99,0,1.713-0.812,1.713-1.805c0,0,0-10.642,0-12.808C38.977,25.482,9.033,25.572,10.025,25.572z"/>
+				<path fill="#FFEE00" d="M10.07,25.595c0,2.158,0,12.768,0,12.768c0,0.989,0.719,1.708,1.618,1.708h24.635
+					c0.987,0,1.706-0.809,1.706-1.798c0,0,0-10.607,0-12.768C38.93,25.505,9.081,25.595,10.07,25.595z"/>
+				<path fill="#FFEF00" d="M10.114,25.618c0,2.151,0,12.727,0,12.727c0,0.986,0.717,1.703,1.613,1.703h24.555
+					c0.985,0,1.702-0.808,1.702-1.793c0,0,0-10.573,0-12.726C38.881,25.529,9.129,25.618,10.114,25.618z"/>
+				<path fill="#FFF000" d="M10.159,25.642c0,2.145,0,12.686,0,12.686c0,0.982,0.714,1.696,1.608,1.696h24.476
+					c0.981,0,1.696-0.804,1.696-1.786c0,0,0-10.54,0-12.685C38.833,25.553,9.177,25.642,10.159,25.642z"/>
+				<path fill="#FFF100" d="M10.204,25.665c0,2.138,0,12.644,0,12.644c0,0.979,0.712,1.692,1.603,1.692h24.397
+					c0.979,0,1.69-0.802,1.69-1.78c0,0,0-10.507,0-12.644C38.785,25.577,9.225,25.665,10.204,25.665z"/>
+				<path fill="#FFF200" d="M10.249,25.688c0,2.131,0,12.603,0,12.603c0,0.978,0.71,1.688,1.597,1.688h24.318
+					c0.977,0,1.686-0.799,1.686-1.773c0,0,0-10.473,0-12.604C38.736,25.6,9.273,25.688,10.249,25.688z"/>
+				<path fill="#FFF300" d="M10.294,25.71c0,2.125,0,12.562,0,12.562c0,0.975,0.708,1.682,1.592,1.682h24.239
+					c0.973,0,1.68-0.797,1.68-1.77c0,0,0-10.438,0-12.562C38.689,25.624,9.321,25.71,10.294,25.71z"/>
+				<path fill="#FFF400" d="M10.339,25.733c0,2.117,0,12.521,0,12.521c0,0.97,0.705,1.675,1.587,1.675h24.16
+					c0.969,0,1.674-0.793,1.674-1.763c0,0,0-10.403,0-12.521C38.643,25.646,9.369,25.733,10.339,25.733z"/>
+				<path fill="#FFF500" d="M10.384,25.757c0,2.109,0,12.479,0,12.479c0,0.969,0.703,1.67,1.582,1.67h24.081
+					c0.967,0,1.669-0.79,1.669-1.757c0,0,0-10.369,0-12.479C38.596,25.669,9.417,25.757,10.384,25.757z"/>
+				<path fill="#FFF600" d="M10.428,25.779c0,2.104,0,12.438,0,12.438c0,0.965,0.701,1.664,1.577,1.664h24.002
+					c0.964,0,1.663-0.787,1.663-1.75c0,0,0-10.336,0-12.438C38.547,25.693,9.465,25.779,10.428,25.779z"/>
+				<path fill="#FFF700" d="M10.473,25.803c0,2.097,0,12.397,0,12.397c0,0.961,0.698,1.659,1.571,1.659h23.923
+					c0.96,0,1.658-0.786,1.658-1.746c0,0,0-10.302,0-12.397C38.499,25.716,9.513,25.803,10.473,25.803z"/>
+				<path fill="#FFF800" d="M10.518,25.827c0,2.088,0,12.355,0,12.355c0,0.958,0.696,1.654,1.566,1.654h23.844
+					c0.957,0,1.653-0.783,1.653-1.74c0,0,0-10.268,0-12.356C38.451,25.74,9.561,25.827,10.518,25.827z"/>
+				<path fill="#FFF900" d="M10.563,25.849c0,2.083,0,12.316,0,12.316c0,0.953,0.693,1.647,1.561,1.647h23.765
+					c0.953,0,1.647-0.78,1.647-1.733c0,0,0-10.233,0-12.316C38.402,25.763,9.609,25.849,10.563,25.849z"/>
+				<path fill="#FFFA00" d="M10.608,25.872c0,2.075,0,12.275,0,12.275c0,0.951,0.691,1.643,1.556,1.643H35.85
+					c0.95,0,1.643-0.777,1.643-1.729c0,0,0-10.199,0-12.275C38.355,25.786,9.657,25.872,10.608,25.872z"/>
+				<path fill="#FFFB00" d="M10.653,25.896c0,2.068,0,12.232,0,12.232c0,0.949,0.689,1.639,1.55,1.639h23.607
+					c0.946,0,1.637-0.775,1.637-1.723c0,0,0-10.166,0-12.234C38.309,25.81,9.705,25.896,10.653,25.896z"/>
+				<path fill="#FFFC00" d="M10.697,25.917c0,2.062,0,12.193,0,12.193c0,0.945,0.687,1.633,1.545,1.633H35.77
+					c0.944,0,1.631-0.772,1.631-1.718c0,0,0-10.132,0-12.192C38.262,25.833,9.753,25.917,10.697,25.917z"/>
+				<path fill="#FFFD00" d="M10.742,25.941c0,2.056,0,12.151,0,12.151c0,0.941,0.685,1.627,1.541,1.627h23.449
+					c0.939,0,1.625-0.771,1.625-1.711c0,0,0-10.098,0-12.152C38.213,25.856,9.801,25.941,10.742,25.941z"/>
+				<path fill="#FFFE00" d="M10.787,25.964c0,2.048,0,12.11,0,12.11c0,0.939,0.682,1.621,1.535,1.621h23.37
+					c0.938,0,1.619-0.768,1.619-1.705c0,0,0-10.062,0-12.11C38.165,25.88,9.849,25.964,10.787,25.964z"/>
+				<path fill="#FFFF00" d="M10.832,25.987c0,2.041,0,12.07,0,12.07c0,0.936,0.68,1.615,1.53,1.615h23.291
+					c0.936,0,1.615-0.766,1.615-1.699c0,0,0-10.029,0-12.07C38.117,25.903,9.897,25.987,10.832,25.987z"/>
+			</g>
+			
+				<linearGradient id="House_Highlight_1_" gradientUnits="userSpaceOnUse" x1="210.0469" y1="-255.9038" x2="210.0469" y2="-269.6733" gradientTransform="matrix(1 0 0 -1 -186 -230)">
+				<stop  offset="0" style="stop-color:#FFFFFF"/>
+				<stop  offset="1" style="stop-color:#FFFF00"/>
+			</linearGradient>
+			<path id="House_Highlight" fill="url(#House_Highlight_1_)" d="M10.832,25.987c0,2.041,0,12.07,0,12.07
+				c0,0.936,0.68,1.615,1.53,1.615h23.291c0.936,0,1.615-0.766,1.615-1.699c0,0,0-10.029,0-12.07
+				C38.117,25.903,9.897,25.987,10.832,25.987z"/>
+		</g>
+		<g id="Roof">
+			<g>
+				<path fill="#006600" d="M22.8,6.963l-17.7,15.1l0,0c-0.3,0.301-0.5,0.801-0.5,1.2c0,0.2,0,0.399,0.1,0.601c0.3,0.6,0.9,1,1.6,1
+					l35.3-0.1c0.801,0,1.4-0.5,1.7-1.201c0.101-0.199,0.101-0.4,0.101-0.6c0-0.5-0.199-1-0.699-1.4L25.4,6.963l0.1,0.1
+					C24.8,6.363,23.7,6.263,22.8,6.963L22.8,6.963z"/>
+				<path fill="#006700" d="M22.803,6.989L5.155,22.044l0,0c-0.299,0.3-0.499,0.799-0.499,1.197c0,0.2,0,0.398,0.1,0.599
+					c0.299,0.598,0.897,0.997,1.595,0.997l35.198-0.1c0.799,0,1.396-0.5,1.695-1.197c0.102-0.198,0.102-0.399,0.102-0.598
+					c0-0.498-0.199-0.997-0.699-1.396L25.396,6.989l0.1,0.099C24.798,6.391,23.701,6.291,22.803,6.989L22.803,6.989z"/>
+				<path fill="#006800" d="M22.807,7.014L5.209,22.026l0,0c-0.298,0.299-0.497,0.796-0.497,1.193c0,0.199,0,0.397,0.1,0.598
+					c0.298,0.596,0.895,0.994,1.591,0.994l35.096-0.1c0.796,0,1.394-0.498,1.69-1.194c0.1-0.198,0.1-0.397,0.1-0.596
+					c0-0.497-0.198-0.995-0.696-1.393l-17.2-14.514l0.099,0.099C24.795,6.417,23.702,6.317,22.807,7.014L22.807,7.014z"/>
+				<path fill="#006900" d="M22.81,7.039L5.264,22.008l0,0c-0.298,0.298-0.496,0.793-0.496,1.189c0,0.198,0,0.396,0.099,0.596
+					c0.297,0.594,0.893,0.99,1.586,0.99l34.995-0.099c0.794,0,1.388-0.497,1.686-1.19c0.101-0.198,0.101-0.397,0.101-0.594
+					c0-0.496-0.198-0.991-0.694-1.389L25.389,7.039l0.1,0.099C24.793,6.444,23.703,6.345,22.81,7.039L22.81,7.039z"/>
+				<path fill="#006A00" d="M22.814,7.064L5.318,21.989l0,0c-0.296,0.298-0.494,0.792-0.494,1.187c0,0.198,0,0.395,0.099,0.594
+					c0.295,0.593,0.89,0.987,1.582,0.987l34.892-0.098c0.793,0,1.386-0.494,1.682-1.187c0.1-0.197,0.1-0.396,0.1-0.593
+					c0-0.494-0.197-0.988-0.691-1.384l-17.1-14.431l0.098,0.099C24.791,6.471,23.704,6.372,22.814,7.064L22.814,7.064z"/>
+				<path fill="#006B00" d="M22.817,7.089L5.373,21.971l0,0C5.077,22.267,4.88,22.76,4.88,23.154c0,0.197,0,0.394,0.099,0.592
+					c0.295,0.591,0.887,0.984,1.577,0.984l34.792-0.099c0.789,0,1.381-0.493,1.676-1.183c0.1-0.196,0.1-0.395,0.1-0.591
+					c0-0.493-0.197-0.986-0.689-1.38L25.381,7.089l0.098,0.098C24.788,6.498,23.705,6.399,22.817,7.089L22.817,7.089z"/>
+				<path fill="#006C00" d="M22.821,7.114L5.427,21.953l0,0c-0.295,0.295-0.492,0.787-0.492,1.179c0,0.197,0,0.393,0.099,0.59
+					c0.294,0.589,0.884,0.981,1.572,0.981l34.688-0.098c0.787,0,1.376-0.492,1.671-1.181c0.1-0.196,0.1-0.393,0.1-0.589
+					c0-0.492-0.196-0.983-0.688-1.376l-17-14.347l0.099,0.098C24.786,6.524,23.706,6.426,22.821,7.114L22.821,7.114z"/>
+				<path fill="#006D00" d="M22.824,7.139L5.481,21.934l0,0c-0.294,0.295-0.49,0.785-0.49,1.176c0,0.196,0,0.391,0.098,0.589
+					c0.293,0.587,0.882,0.98,1.567,0.98l34.587-0.099c0.784,0,1.372-0.49,1.666-1.176c0.099-0.195,0.099-0.393,0.099-0.588
+					c0-0.49-0.195-0.979-0.688-1.372L25.372,7.139l0.099,0.098C24.783,6.551,23.706,6.453,22.824,7.139L22.824,7.139z"/>
+				<path fill="#006E00" d="M22.827,7.164L5.536,21.915l0,0c-0.293,0.294-0.488,0.783-0.488,1.173c0,0.195,0,0.39,0.098,0.587
+					c0.293,0.585,0.879,0.977,1.563,0.977l34.484-0.097c0.783,0,1.369-0.49,1.662-1.173c0.098-0.194,0.098-0.391,0.098-0.586
+					c0-0.489-0.195-0.977-0.684-1.368L25.367,7.164l0.098,0.098C24.781,6.578,23.707,6.48,22.827,7.164L22.827,7.164z"/>
+				<path fill="#006F00" d="M22.831,7.189L5.591,21.897l0,0c-0.292,0.292-0.487,0.78-0.487,1.168c0,0.195,0,0.39,0.097,0.585
+					c0.292,0.584,0.876,0.973,1.558,0.973l34.384-0.097c0.779,0,1.363-0.487,1.655-1.169c0.099-0.194,0.099-0.39,0.099-0.584
+					c0-0.487-0.194-0.974-0.683-1.364L25.363,7.189l0.099,0.098C24.779,6.605,23.708,6.507,22.831,7.189L22.831,7.189z"/>
+				<path fill="#007000" d="M22.834,7.215L5.646,21.879l0,0c-0.292,0.292-0.486,0.778-0.486,1.165c0,0.195,0,0.388,0.098,0.584
+					c0.291,0.582,0.874,0.971,1.554,0.971l34.281-0.098c0.778,0,1.36-0.485,1.651-1.166c0.098-0.193,0.098-0.389,0.098-0.583
+					c0-0.485-0.193-0.971-0.68-1.36L25.359,7.215l0.098,0.097C24.775,6.632,23.709,6.535,22.834,7.215L22.834,7.215z"/>
+				<path fill="#007100" d="M22.838,7.24L5.7,21.86l0,0c-0.291,0.292-0.484,0.775-0.484,1.162c0,0.194,0,0.387,0.097,0.582
+					c0.29,0.58,0.871,0.967,1.549,0.967l34.18-0.096c0.774,0,1.354-0.484,1.646-1.162c0.1-0.193,0.1-0.388,0.1-0.581
+					c0-0.484-0.194-0.968-0.68-1.356L25.355,7.24l0.097,0.097C24.773,6.659,23.709,6.562,22.838,7.24L22.838,7.24z"/>
+				<path fill="#007200" d="M22.842,7.265L5.755,21.842l0,0C5.465,22.133,5.272,22.615,5.272,23c0,0.194,0,0.386,0.097,0.581
+					c0.289,0.578,0.868,0.964,1.544,0.964l34.077-0.096c0.773,0,1.353-0.483,1.642-1.159c0.097-0.192,0.097-0.387,0.097-0.579
+					c0-0.483-0.191-0.965-0.676-1.352L25.352,7.265l0.098,0.096C24.771,6.686,23.711,6.589,22.842,7.265L22.842,7.265z"/>
+				<path fill="#007300" d="M22.845,7.29L5.809,21.824l0,0c-0.29,0.29-0.481,0.771-0.481,1.155c0,0.193,0,0.385,0.096,0.579
+					c0.289,0.577,0.867,0.961,1.54,0.961l33.976-0.097c0.771,0,1.35-0.481,1.638-1.155c0.097-0.192,0.097-0.386,0.097-0.577
+					c0-0.481-0.191-0.963-0.674-1.348L25.348,7.29l0.098,0.096C24.771,6.712,23.711,6.616,22.845,7.29L22.845,7.29z"/>
+				<path fill="#007400" d="M22.848,7.315L5.863,21.805l0,0c-0.288,0.289-0.48,0.769-0.48,1.152c0,0.192,0,0.383,0.096,0.576
+					c0.288,0.575,0.864,0.959,1.535,0.959l33.875-0.096c0.769,0,1.344-0.479,1.631-1.152c0.098-0.191,0.098-0.384,0.098-0.575
+					c0-0.479-0.192-0.959-0.672-1.344L25.344,7.315l0.096,0.096C24.768,6.739,23.712,6.643,22.848,7.315L22.848,7.315z"/>
+				<path fill="#007500" d="M22.852,7.34L5.918,21.787l0,0c-0.288,0.288-0.479,0.767-0.479,1.148c0,0.191,0,0.382,0.096,0.575
+					c0.287,0.574,0.861,0.956,1.53,0.956l33.772-0.096c0.767,0,1.34-0.478,1.627-1.148c0.097-0.19,0.097-0.383,0.097-0.574
+					c0-0.479-0.19-0.957-0.67-1.34L25.34,7.34l0.096,0.095C24.766,6.767,23.713,6.67,22.852,7.34L22.852,7.34z"/>
+				<path fill="#007600" d="M22.855,7.365L5.973,21.768l0,0c-0.287,0.287-0.477,0.764-0.477,1.145c0,0.191,0,0.381,0.095,0.573
+					c0.286,0.572,0.858,0.953,1.526,0.953l33.67-0.095c0.764,0,1.336-0.477,1.622-1.146c0.096-0.19,0.096-0.382,0.096-0.572
+					c0-0.477-0.19-0.954-0.668-1.336L25.336,7.365l0.096,0.095C24.764,6.793,23.714,6.697,22.855,7.365L22.855,7.365z"/>
+				<path fill="#007700" d="M22.858,7.391L6.027,21.75l0,0c-0.286,0.286-0.476,0.762-0.476,1.142c0,0.19,0,0.38,0.095,0.571
+					c0.285,0.57,0.856,0.95,1.521,0.95l33.567-0.095c0.763,0,1.332-0.476,1.617-1.141c0.097-0.189,0.097-0.381,0.097-0.57
+					c0-0.476-0.19-0.951-0.666-1.332L25.331,7.391l0.096,0.095C24.762,6.82,23.715,6.725,22.858,7.391L22.858,7.391z"/>
+				<path fill="#007800" d="M22.862,7.416L6.082,21.731l0,0c-0.285,0.285-0.475,0.759-0.475,1.138c0,0.19,0,0.379,0.095,0.57
+					c0.284,0.568,0.854,0.947,1.517,0.947l33.467-0.095c0.76,0,1.328-0.474,1.61-1.138c0.097-0.189,0.097-0.379,0.097-0.568
+					c0-0.474-0.189-0.948-0.664-1.328L25.327,7.416l0.095,0.095C24.758,6.847,23.716,6.751,22.862,7.416L22.862,7.416z"/>
+				<path fill="#007900" d="M22.865,7.441L6.136,21.713l0,0c-0.284,0.284-0.473,0.757-0.473,1.135c0,0.189,0,0.377,0.095,0.567
+					c0.283,0.567,0.851,0.944,1.512,0.944l33.365-0.094c0.758,0,1.324-0.473,1.607-1.135c0.095-0.188,0.095-0.378,0.095-0.566
+					c0-0.473-0.188-0.945-0.662-1.324L25.323,7.441l0.095,0.094C24.756,6.874,23.716,6.779,22.865,7.441L22.865,7.441z"/>
+				<path fill="#007A00" d="M22.869,7.466L6.19,21.694l0,0c-0.283,0.283-0.471,0.754-0.471,1.131c0,0.188,0,0.376,0.094,0.566
+					c0.283,0.564,0.848,0.941,1.507,0.941l33.263-0.094c0.755,0,1.319-0.471,1.603-1.131c0.096-0.188,0.096-0.377,0.096-0.565
+					c0-0.471-0.188-0.942-0.66-1.32L25.318,7.466l0.095,0.094C24.754,6.901,23.717,6.806,22.869,7.466L22.869,7.466z"/>
+				<path fill="#007B00" d="M22.872,7.491L6.245,21.676l0,0c-0.282,0.283-0.47,0.752-0.47,1.128c0,0.188,0,0.375,0.094,0.564
+					c0.282,0.563,0.846,0.939,1.503,0.939l33.161-0.094c0.753,0,1.316-0.469,1.598-1.127c0.096-0.187,0.096-0.376,0.096-0.563
+					c0-0.47-0.188-0.939-0.658-1.316L25.314,7.491l0.095,0.094C24.751,6.927,23.718,6.833,22.872,7.491L22.872,7.491z"/>
+				<path fill="#007C00" d="M22.876,7.516L6.299,21.658l0,0c-0.281,0.281-0.468,0.75-0.468,1.124c0,0.188,0,0.374,0.094,0.562
+					c0.281,0.562,0.843,0.936,1.499,0.936l33.059-0.093c0.75,0,1.312-0.468,1.594-1.124c0.094-0.187,0.094-0.375,0.094-0.562
+					c0-0.468-0.188-0.937-0.656-1.312L25.312,7.516l0.094,0.094C24.749,6.954,23.719,6.86,22.876,7.516L22.876,7.516z"/>
+				<path fill="#007D00" d="M22.879,7.542L6.354,21.639l0,0c-0.281,0.281-0.467,0.748-0.467,1.121c0,0.187,0,0.373,0.094,0.561
+					c0.28,0.56,0.84,0.933,1.494,0.933l32.958-0.093c0.748,0,1.308-0.467,1.586-1.121c0.096-0.186,0.096-0.374,0.096-0.56
+					c0-0.467-0.188-0.934-0.654-1.307L25.307,7.542L25.4,7.635C24.746,6.981,23.72,6.887,22.879,7.542L22.879,7.542z"/>
+				<path fill="#007E00" d="M22.883,7.566L6.408,21.621l0,0c-0.279,0.28-0.465,0.745-0.465,1.117c0,0.187,0,0.372,0.093,0.559
+					c0.279,0.558,0.838,0.93,1.489,0.93l32.856-0.093c0.746,0,1.305-0.465,1.583-1.117c0.095-0.186,0.095-0.373,0.095-0.559
+					c0-0.465-0.188-0.93-0.652-1.303L25.303,7.566l0.094,0.093C24.744,7.008,23.721,6.915,22.883,7.566L22.883,7.566z"/>
+				<path fill="#007F00" d="M22.886,7.592L6.463,21.603l0,0c-0.279,0.279-0.464,0.743-0.464,1.113c0,0.186,0,0.371,0.093,0.558
+					c0.278,0.556,0.835,0.927,1.484,0.927l32.754-0.092c0.743,0,1.3-0.464,1.577-1.114c0.094-0.185,0.094-0.372,0.094-0.557
+					c0-0.464-0.187-0.928-0.649-1.299L25.299,7.592l0.094,0.092C24.742,7.035,23.722,6.941,22.886,7.592L22.886,7.592z"/>
+				<path fill="#007F00" d="M22.89,7.617L6.518,21.584l0,0c-0.278,0.278-0.462,0.741-0.462,1.11c0,0.185,0,0.369,0.092,0.556
+					c0.276,0.555,0.833,0.924,1.48,0.924l32.651-0.092c0.742,0,1.297-0.462,1.572-1.11c0.094-0.185,0.094-0.371,0.094-0.555
+					c0-0.462-0.186-0.925-0.647-1.295L25.295,7.617l0.094,0.092C24.738,7.062,23.723,6.969,22.89,7.617L22.89,7.617z"/>
+				<path fill="#008000" d="M22.893,7.642L6.572,21.565l0,0c-0.277,0.277-0.461,0.739-0.461,1.107c0,0.185,0,0.368,0.092,0.554
+					c0.276,0.553,0.83,0.921,1.475,0.921l32.55-0.092c0.738,0,1.291-0.461,1.566-1.106c0.094-0.184,0.094-0.369,0.094-0.553
+					c0-0.461-0.185-0.922-0.646-1.292L25.291,7.642l0.093,0.092C24.736,7.088,23.724,6.996,22.893,7.642L22.893,7.642z"/>
+				<path fill="#008100" d="M22.896,7.667l-16.27,13.88l0,0c-0.276,0.277-0.459,0.736-0.459,1.104c0,0.184,0,0.367,0.092,0.552
+					c0.275,0.551,0.827,0.918,1.471,0.918l32.448-0.091c0.736,0,1.288-0.459,1.562-1.104c0.093-0.183,0.093-0.368,0.093-0.551
+					c0-0.459-0.185-0.919-0.644-1.287L25.287,7.667l0.092,0.092C24.734,7.116,23.725,7.023,22.896,7.667L22.896,7.667z"/>
+				<path fill="#008200" d="M22.9,7.692L6.681,21.529l0,0c-0.275,0.275-0.458,0.734-0.458,1.1c0,0.184,0,0.366,0.092,0.55
+					c0.275,0.549,0.825,0.916,1.466,0.916l32.347-0.091c0.733,0,1.284-0.458,1.558-1.1c0.094-0.183,0.094-0.367,0.094-0.55
+					c0-0.458-0.184-0.917-0.643-1.283L25.282,7.692l0.093,0.091C24.732,7.143,23.725,7.05,22.9,7.692L22.9,7.692z"/>
+				<path fill="#008300" d="M22.903,7.717L6.735,21.51l0,0c-0.274,0.275-0.457,0.731-0.457,1.096c0,0.183,0,0.365,0.091,0.549
+					c0.274,0.547,0.822,0.913,1.461,0.913l32.245-0.091c0.731,0,1.28-0.457,1.554-1.096c0.092-0.182,0.092-0.366,0.092-0.548
+					c0-0.457-0.183-0.914-0.64-1.279L25.277,7.717l0.093,0.091C24.73,7.169,23.726,7.078,22.903,7.717L22.903,7.717z"/>
+				<path fill="#008400" d="M22.907,7.742L6.79,21.492l0,0c-0.273,0.274-0.456,0.729-0.456,1.093c0,0.183,0,0.364,0.091,0.547
+					c0.273,0.546,0.82,0.909,1.457,0.909l32.144-0.09c0.729,0,1.274-0.455,1.548-1.093c0.092-0.181,0.092-0.364,0.092-0.546
+					c0-0.455-0.183-0.911-0.638-1.275L25.273,7.742l0.093,0.091C24.729,7.196,23.727,7.105,22.907,7.742L22.907,7.742z"/>
+				<path fill="#008500" d="M22.911,7.768L6.845,21.474l0,0c-0.272,0.273-0.454,0.727-0.454,1.089c0,0.182,0,0.363,0.091,0.546
+					c0.272,0.543,0.817,0.906,1.452,0.906l32.041-0.09c0.729,0,1.271-0.454,1.543-1.089c0.092-0.181,0.092-0.363,0.092-0.544
+					c0-0.454-0.182-0.908-0.635-1.271L25.271,7.768l0.09,0.09C24.727,7.223,23.728,7.132,22.911,7.768L22.911,7.768z"/>
+				<path fill="#008600" d="M22.914,7.792L6.899,21.455l0,0c-0.272,0.272-0.453,0.725-0.453,1.086c0,0.181,0,0.361,0.091,0.543
+					c0.271,0.542,0.814,0.904,1.447,0.904l31.939-0.09c0.726,0,1.269-0.452,1.538-1.086c0.092-0.18,0.092-0.362,0.092-0.542
+					c0-0.452-0.181-0.905-0.634-1.267L25.268,7.792l0.09,0.09C24.725,7.25,23.729,7.159,22.914,7.792L22.914,7.792z"/>
+				<path fill="#008700" d="M22.917,7.818L6.954,21.437l0,0c-0.271,0.271-0.451,0.722-0.451,1.083c0,0.181,0,0.36,0.09,0.542
+					c0.271,0.54,0.812,0.901,1.443,0.901l31.837-0.09c0.723,0,1.264-0.451,1.533-1.082c0.092-0.18,0.092-0.361,0.092-0.541
+					c0-0.451-0.182-0.902-0.633-1.263L25.264,7.818l0.09,0.09C24.723,7.277,23.729,7.186,22.917,7.818L22.917,7.818z"/>
+				<path fill="#008800" d="M22.921,7.843L7.008,21.418l0,0c-0.27,0.27-0.45,0.72-0.45,1.079c0,0.18,0,0.359,0.09,0.54
+					c0.27,0.539,0.809,0.898,1.438,0.898l31.734-0.09c0.722,0,1.261-0.449,1.529-1.079c0.09-0.179,0.09-0.36,0.09-0.539
+					c0-0.449-0.18-0.899-0.629-1.259L25.259,7.843l0.091,0.09C24.719,7.303,23.73,7.213,22.921,7.843L22.921,7.843z"/>
+				<path fill="#008900" d="M22.924,7.868L7.062,21.4l0,0c-0.269,0.269-0.448,0.717-0.448,1.075c0,0.18,0,0.358,0.09,0.539
+					c0.269,0.537,0.807,0.895,1.434,0.895l31.633-0.089c0.72,0,1.256-0.448,1.523-1.075c0.092-0.179,0.092-0.359,0.092-0.538
+					c0-0.448-0.181-0.896-0.629-1.255L25.255,7.868l0.091,0.089C24.717,7.331,23.731,7.241,22.924,7.868L22.924,7.868z"/>
+				<path fill="#008A00" d="M22.928,7.893L7.117,21.381l0,0C6.849,21.65,6.67,22.097,6.67,22.453c0,0.179,0,0.357,0.089,0.537
+					c0.268,0.536,0.804,0.893,1.429,0.893l31.533-0.089c0.715,0,1.252-0.446,1.518-1.072c0.092-0.178,0.092-0.358,0.092-0.536
+					c0-0.446-0.18-0.894-0.626-1.251L25.25,7.893l0.09,0.089C24.714,7.357,23.732,7.268,22.928,7.893L22.928,7.893z"/>
+				<path fill="#008B00" d="M22.931,7.918L7.172,21.363l0,0c-0.268,0.268-0.445,0.713-0.445,1.069c0,0.178,0,0.355,0.089,0.535
+					c0.267,0.534,0.801,0.89,1.424,0.89l31.43-0.089c0.714,0,1.248-0.445,1.514-1.068c0.09-0.178,0.09-0.357,0.09-0.534
+					c0-0.445-0.178-0.891-0.623-1.247L25.246,7.918l0.09,0.089C24.712,7.384,23.733,7.295,22.931,7.918L22.931,7.918z"/>
+				<path fill="#008C00" d="M22.935,7.943L7.227,21.345l0,0c-0.267,0.267-0.444,0.71-0.444,1.065c0,0.178,0,0.354,0.089,0.533
+					c0.266,0.532,0.799,0.887,1.42,0.887l31.328-0.089c0.711,0,1.243-0.443,1.509-1.065c0.09-0.177,0.09-0.355,0.09-0.532
+					c0-0.444-0.178-0.888-0.621-1.243L25.242,7.943l0.089,0.089C24.71,7.411,23.734,7.322,22.935,7.943L22.935,7.943z"/>
+				<path fill="#008D00" d="M22.938,7.968L7.281,21.326l0,0c-0.266,0.266-0.442,0.708-0.442,1.062c0,0.177,0,0.353,0.088,0.532
+					c0.264,0.53,0.796,0.883,1.415,0.883l31.227-0.088c0.709,0,1.24-0.442,1.505-1.062c0.09-0.176,0.09-0.354,0.09-0.53
+					c0-0.442-0.177-0.885-0.62-1.239L25.238,7.968l0.089,0.088C24.707,7.438,23.735,7.349,22.938,7.968L22.938,7.968z"/>
+				<path fill="#008E00" d="M22.941,7.994L7.335,21.308l0,0c-0.265,0.265-0.441,0.706-0.441,1.058c0,0.177,0,0.352,0.088,0.53
+					c0.264,0.528,0.793,0.881,1.411,0.881l31.125-0.088c0.707,0,1.235-0.441,1.5-1.058c0.088-0.176,0.088-0.353,0.088-0.529
+					c0-0.441-0.176-0.882-0.617-1.235L25.234,7.994l0.089,0.088C24.705,7.465,23.736,7.376,22.941,7.994L22.941,7.994z"/>
+				<path fill="#008F00" d="M22.945,8.019L7.39,21.289l0,0c-0.264,0.264-0.44,0.704-0.44,1.055c0,0.176,0,0.351,0.088,0.528
+					c0.263,0.527,0.791,0.878,1.406,0.878l31.022-0.088c0.704,0,1.231-0.439,1.494-1.055c0.089-0.175,0.089-0.352,0.089-0.527
+					c0-0.439-0.176-0.879-0.615-1.231L25.229,8.019l0.09,0.088C24.703,7.492,23.736,7.403,22.945,8.019L22.945,8.019z"/>
+				<path fill="#009000" d="M22.948,8.044L7.444,21.271l0,0c-0.263,0.263-0.438,0.701-0.438,1.051c0,0.175,0,0.35,0.087,0.526
+					c0.263,0.525,0.789,0.875,1.401,0.875l30.921-0.088c0.702,0,1.228-0.438,1.489-1.051c0.089-0.174,0.089-0.351,0.089-0.525
+					c0-0.438-0.177-0.876-0.614-1.227L25.227,8.044l0.088,0.087C24.7,7.519,23.737,7.431,22.948,8.044L22.948,8.044z"/>
+				<path fill="#009100" d="M22.952,8.069L7.499,21.252l0,0c-0.262,0.262-0.437,0.699-0.437,1.048c0,0.175,0,0.349,0.087,0.524
+					c0.262,0.523,0.786,0.872,1.397,0.872l30.819-0.087c0.699,0,1.224-0.436,1.484-1.047c0.088-0.174,0.088-0.35,0.088-0.524
+					c0-0.436-0.174-0.873-0.611-1.223L25.223,8.069l0.088,0.087C24.698,7.545,23.738,7.458,22.952,8.069L22.952,8.069z"/>
+				<path fill="#009200" d="M22.955,8.094L7.553,21.234l0,0c-0.261,0.262-0.435,0.697-0.435,1.044c0,0.174,0,0.347,0.087,0.523
+					c0.259,0.521,0.783,0.869,1.392,0.869l30.717-0.087c0.697,0,1.22-0.435,1.479-1.044c0.088-0.173,0.088-0.348,0.088-0.522
+					c0-0.435-0.174-0.87-0.609-1.218L25.218,8.094l0.089,0.087C24.695,7.572,23.739,7.485,22.955,8.094L22.955,8.094z"/>
+				<path fill="#009300" d="M22.959,8.119L7.608,21.215l0,0c-0.26,0.261-0.434,0.695-0.434,1.041c0,0.174,0,0.346,0.087,0.521
+					c0.26,0.52,0.781,0.867,1.388,0.867l30.615-0.087c0.695,0,1.217-0.434,1.475-1.041c0.089-0.173,0.089-0.348,0.089-0.521
+					c0-0.433-0.175-0.867-0.606-1.214L25.214,8.119l0.088,0.087C24.693,7.599,23.74,7.512,22.959,8.119L22.959,8.119z"/>
+				<path fill="#009400" d="M22.962,8.145l-15.3,13.053l0,0c-0.26,0.26-0.433,0.692-0.433,1.037c0,0.173,0,0.345,0.086,0.52
+					c0.259,0.518,0.778,0.863,1.383,0.863l30.514-0.086c0.692,0,1.212-0.432,1.47-1.038c0.088-0.172,0.088-0.346,0.088-0.519
+					c0-0.432-0.172-0.864-0.605-1.21L25.21,8.145l0.087,0.086C24.691,7.626,23.741,7.539,22.962,8.145L22.962,8.145z"/>
+				<path fill="#009500" d="M22.966,8.169L7.717,21.179l0,0c-0.259,0.259-0.431,0.69-0.431,1.034c0,0.173,0,0.344,0.086,0.518
+					c0.257,0.517,0.775,0.86,1.378,0.86l30.412-0.086c0.689,0,1.207-0.431,1.465-1.034c0.087-0.171,0.087-0.345,0.087-0.517
+					c0-0.431-0.172-0.861-0.604-1.207L25.206,8.169l0.087,0.086C24.688,7.653,23.742,7.566,22.966,8.169L22.966,8.169z"/>
+				<path fill="#009600" d="M22.969,8.195L7.771,21.16l0,0c-0.258,0.258-0.43,0.688-0.43,1.03c0,0.172,0,0.343,0.086,0.516
+					c0.257,0.515,0.773,0.858,1.374,0.858l30.311-0.086c0.688,0,1.203-0.429,1.459-1.03c0.088-0.171,0.088-0.344,0.088-0.515
+					c0-0.429-0.172-0.859-0.602-1.203L25.201,8.195l0.087,0.085C24.688,7.68,23.743,7.593,22.969,8.195L22.969,8.195z"/>
+				<path fill="#009700" d="M22.973,8.22L7.826,21.142l0,0c-0.257,0.257-0.428,0.686-0.428,1.027c0,0.171,0,0.341,0.085,0.514
+					c0.255,0.513,0.771,0.855,1.369,0.855l30.208-0.086c0.687,0,1.198-0.428,1.455-1.027c0.086-0.17,0.086-0.343,0.086-0.513
+					c0-0.428-0.172-0.856-0.6-1.198L25.197,8.22l0.087,0.085C24.686,7.707,23.743,7.621,22.973,8.22L22.973,8.22z"/>
+				<path fill="#009800" d="M22.976,8.245L7.88,21.124l0,0c-0.256,0.256-0.427,0.683-0.427,1.023c0,0.171,0,0.34,0.085,0.512
+					c0.256,0.511,0.768,0.852,1.364,0.852l30.106-0.085c0.684,0,1.195-0.426,1.45-1.023c0.086-0.17,0.086-0.342,0.086-0.512
+					c0-0.426-0.17-0.853-0.599-1.194L25.193,8.245l0.086,0.085C24.682,7.733,23.744,7.647,22.976,8.245L22.976,8.245z"/>
+				<path fill="#009900" d="M22.979,8.27L7.935,21.105l0,0C7.68,21.36,7.51,21.786,7.51,22.125c0,0.17,0,0.339,0.085,0.511
+					c0.255,0.509,0.765,0.849,1.36,0.849L38.959,23.4c0.682,0,1.191-0.425,1.445-1.02c0.086-0.169,0.086-0.34,0.086-0.51
+					c0-0.425-0.17-0.85-0.596-1.19L25.189,8.27l0.086,0.085C24.68,7.76,23.745,7.675,22.979,8.27L22.979,8.27z"/>
+			</g>
+			
+				<linearGradient id="Roof_Highlight_1_" gradientUnits="userSpaceOnUse" x1="210" y1="-237.8638" x2="210" y2="-253.4849" gradientTransform="matrix(1 0 0 -1 -186 -230)">
+				<stop  offset="0" style="stop-color:#FFFFFF"/>
+				<stop  offset="1" style="stop-color:#009900"/>
+			</linearGradient>
+			<path id="Roof_Highlight" fill="url(#Roof_Highlight_1_)" d="M22.979,8.27L7.935,21.105l0,0C7.68,21.36,7.51,21.786,7.51,22.125
+				c0,0.17,0,0.339,0.085,0.51c0.255,0.51,0.765,0.85,1.36,0.85L38.959,23.4c0.682,0,1.191-0.425,1.445-1.021
+				c0.086-0.169,0.086-0.34,0.086-0.51c0-0.424-0.17-0.85-0.596-1.189L25.189,8.27l0.086,0.085C24.68,7.76,23.745,7.675,22.979,8.27
+				L22.979,8.27z"/>
+		</g>
+	</g>
+</g>
+<g id="Layer_2">
+	<g id="crop_x0020_marks">
+		<path fill="none" d="M48,47.687H0v-48h48V47.687z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/important.svg b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/important.svg
new file mode 100644
index 0000000..803ad8d
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/important.svg
@@ -0,0 +1,239 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.1" id="Caution" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="48" height="48" viewBox="0 0 48 48"
+	 overflow="visible" enable-background="new 0 0 48 48" xml:space="preserve">
+<g>
+	<path stroke="#FFFFFF" stroke-width="6.6112" d="M42.35,35.841L27.248,9.941c-0.602-1-1.699-1.7-2.899-1.6c-1.2,0-2.3,0.7-2.9,1.7
+		l-14.5,25.901c-0.6,1-0.6,2.299,0,3.299c0.6,1,1.7,1.6,2.9,1.6h29.601c1.199,0,2.301-0.6,2.898-1.697
+		C42.949,38.142,42.949,36.841,42.35,35.841L42.35,35.841z"/>
+	<g>
+		<path fill="#FFFFFF" stroke="#009900" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" d="M24.349,11.586
+			l-14.5,26h29.601L24.349,11.586z"/>
+		<polygon fill="#FFFFFF" stroke="#009A00" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.35,11.611 9.877,37.562 39.42,37.562 		"/>
+		<polygon fill="#FFFFFF" stroke="#009B01" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.35,11.637 9.907,37.536 39.391,37.536 		"/>
+		<polygon fill="#FFFFFF" stroke="#009C01" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.351,11.662 9.935,37.511 39.361,37.511 		"/>
+		<polygon fill="#FFFFFF" stroke="#009D02" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.352,11.688 9.963,37.485 39.334,37.485 		"/>
+		<polygon fill="#FFFFFF" stroke="#009E02" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.352,11.712 9.993,37.46 39.305,37.46 		"/>
+		<polygon fill="#FFFFFF" stroke="#009F03" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.353,11.738 10.021,37.435 39.275,37.435 		"/>
+		<polygon fill="#FFFFFF" stroke="#00A003" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.353,11.763 10.049,37.409 39.248,37.409 		"/>
+		<polygon fill="#FFFFFF" stroke="#00A104" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.354,11.789 10.079,37.386 39.219,37.386 		"/>
+		<polygon fill="#FFFFFF" stroke="#00A204" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.354,11.813 10.106,37.36 39.189,37.36 		"/>
+		<polygon fill="#FFFFFF" stroke="#00A305" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.354,11.838 10.135,37.335 39.16,37.335 		"/>
+		<polygon fill="#FFFFFF" stroke="#00A405" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.355,11.864 10.166,37.31 39.133,37.31 		"/>
+		<polygon fill="#FFFFFF" stroke="#00A506" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.355,11.89 10.193,37.284 39.104,37.284 		"/>
+		<polygon fill="#FFFFFF" stroke="#00A606" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.355,11.915 10.223,37.259 39.074,37.259 		"/>
+		<polygon fill="#FFFFFF" stroke="#00A707" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.356,11.939 10.25,37.233 39.047,37.233 		"/>
+		<polygon fill="#FFFFFF" stroke="#00A807" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.357,11.965 10.279,37.21 39.018,37.21 		"/>
+		<polygon fill="#FFFFFF" stroke="#00A908" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.357,11.99 10.309,37.183 38.988,37.183 		"/>
+		<polygon fill="#FFFFFF" stroke="#00AA08" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.357,12.016 10.336,37.157 38.959,37.157 		"/>
+		<polygon fill="#FFFFFF" stroke="#00AB09" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.358,12.041 10.367,37.132 38.932,37.132 		"/>
+		<polygon fill="#FFFFFF" stroke="#00AC09" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.359,12.066 10.396,37.106 38.902,37.106 		"/>
+		<polygon fill="#FFFFFF" stroke="#00AD0A" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.359,12.091 10.423,37.083 38.873,37.083 		"/>
+		<polygon fill="#FFFFFF" stroke="#00AE0A" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.36,12.116 10.453,37.056 38.846,37.056 		"/>
+		<polygon fill="#FFFFFF" stroke="#00AF0B" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.361,12.142 10.48,37.032 38.816,37.032 		"/>
+		<polygon fill="#FFFFFF" stroke="#00B00B" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.362,12.167 10.509,37.007 38.789,37.007 		"/>
+		<polygon fill="#FFFFFF" stroke="#00B10C" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.362,12.191 10.539,36.981 38.76,36.981 		"/>
+		<polygon fill="#FFFFFF" stroke="#00B20C" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.362,12.217 10.566,36.956 38.729,36.956 		"/>
+		<polygon fill="#FFFFFF" stroke="#00B30D" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.363,12.242 10.596,36.931 38.701,36.931 		"/>
+		<polygon fill="#FFFFFF" stroke="#00B40D" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.364,12.269 10.625,36.905 38.674,36.905 		"/>
+		<polygon fill="#FFFFFF" stroke="#00B50E" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.364,12.293 10.653,36.88 38.645,36.88 		"/>
+		<polygon fill="#FFFFFF" stroke="#00B60E" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.366,12.317 10.682,36.854 38.613,36.854 		"/>
+		<polygon fill="#FFFFFF" stroke="#00B70F" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.367,12.343 10.71,36.829 38.586,36.829 		"/>
+		<polygon fill="#FFFFFF" stroke="#00B80F" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.367,12.37 10.739,36.804 38.559,36.804 		"/>
+		<polygon fill="#FFFFFF" stroke="#00B910" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.368,12.395 10.769,36.778 38.527,36.778 		"/>
+		<polygon fill="#FFFFFF" stroke="#00BA10" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.368,12.419 10.796,36.755 38.5,36.755 		"/>
+		<polygon fill="#FFFFFF" stroke="#00BB11" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.369,12.444 10.826,36.728 38.471,36.728 		"/>
+		<polygon fill="#FFFFFF" stroke="#00BC11" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.37,12.469 10.854,36.704 38.441,36.704 		"/>
+		<polygon fill="#FFFFFF" stroke="#00BD12" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.37,12.496 10.883,36.677 38.414,36.677 		"/>
+		<polygon fill="#FFFFFF" stroke="#00BE12" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.371,12.521 10.912,36.651 38.385,36.651 		"/>
+		<polygon fill="#FFFFFF" stroke="#00BF13" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.371,12.545 10.94,36.628 38.355,36.628 		"/>
+		<polygon fill="#FFFFFF" stroke="#00C013" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.372,12.57 10.969,36.603 38.328,36.603 		"/>
+		<polygon fill="#FFFFFF" stroke="#00C114" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.372,12.595 10.999,36.577 38.299,36.577 		"/>
+		<polygon fill="#FFFFFF" stroke="#00C214" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.373,12.622 11.026,36.552 38.27,36.552 		"/>
+		<polygon fill="#FFFFFF" stroke="#00C315" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.373,12.646 11.056,36.526 38.242,36.526 		"/>
+		<polygon fill="#FFFFFF" stroke="#00C415" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.374,12.672 11.084,36.503 38.213,36.503 		"/>
+		<polygon fill="#FFFFFF" stroke="#00C516" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.375,12.696 11.113,36.476 38.184,36.476 		"/>
+		<polygon fill="#FFFFFF" stroke="#00C616" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.375,12.721 11.142,36.45 38.154,36.45 		"/>
+		<polygon fill="#FFFFFF" stroke="#00C717" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.375,12.748 11.17,36.425 38.127,36.425 		"/>
+		<polygon fill="#FFFFFF" stroke="#00C817" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.375,12.773 11.2,36.401 38.098,36.401 		"/>
+		<polygon fill="#FFFFFF" stroke="#00C918" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.376,12.797 11.229,36.376 38.068,36.376 		"/>
+		<polygon fill="#FFFFFF" stroke="#00CA18" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.376,12.822 11.256,36.349 38.041,36.349 		"/>
+		<polygon fill="#FFFFFF" stroke="#00CB19" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.377,12.849 11.286,36.325 38.012,36.325 		"/>
+		<polygon fill="#FFFFFF" stroke="#00CC19" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.378,12.875 11.314,36.3 37.982,36.3 		"/>
+		<polygon fill="#FFFFFF" stroke="#00CC1A" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.378,12.899 11.342,36.274 37.955,36.274 		"/>
+		<polygon fill="#FFFFFF" stroke="#00CD1A" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.379,12.923 11.372,36.249 37.926,36.249 		"/>
+		<polygon fill="#FFFFFF" stroke="#00CE1B" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.379,12.949 11.4,36.224 37.896,36.224 		"/>
+		<polygon fill="#FFFFFF" stroke="#00CF1B" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.38,12.975 11.43,36.198 37.867,36.198 		"/>
+		<polygon fill="#FFFFFF" stroke="#00D01C" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.381,13 11.458,36.173 37.84,36.173 		"/>
+		<polygon fill="#FFFFFF" stroke="#00D11C" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.381,13.024 11.486,36.147 37.811,36.147 		"/>
+		<polygon fill="#FFFFFF" stroke="#00D21D" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.381,13.05 11.516,36.124 37.781,36.124 		"/>
+		<polygon fill="#FFFFFF" stroke="#00D31D" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.382,13.075 11.543,36.097 37.754,36.097 		"/>
+		<polygon fill="#FFFFFF" stroke="#00D41E" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.383,13.102 11.572,36.071 37.725,36.071 		"/>
+		<polygon fill="#FFFFFF" stroke="#00D51E" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.383,13.126 11.602,36.046 37.695,36.046 		"/>
+		<polygon fill="#FFFFFF" stroke="#00D61F" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.384,13.151 11.63,36.022 37.666,36.022 		"/>
+		<polygon fill="#FFFFFF" stroke="#00D71F" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.385,13.176 11.66,35.997 37.639,35.997 		"/>
+		<polygon fill="#FFFFFF" stroke="#00D820" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.385,13.201 11.688,35.972 37.609,35.972 		"/>
+		<polygon fill="#FFFFFF" stroke="#00D920" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.387,13.228 11.716,35.946 37.58,35.946 		"/>
+		<polygon fill="#FFFFFF" stroke="#00DA21" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.387,13.252 11.746,35.921 37.553,35.921 		"/>
+		<polygon fill="#FFFFFF" stroke="#00DB21" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.388,13.277 11.773,35.896 37.521,35.896 		"/>
+		<polygon fill="#FFFFFF" stroke="#00DC22" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.389,13.302 11.802,35.872 37.494,35.872 		"/>
+		<polygon fill="#FFFFFF" stroke="#00DD22" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.389,13.327 11.832,35.845 37.465,35.845 		"/>
+		<polygon fill="#FFFFFF" stroke="#00DE23" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.39,13.354 11.86,35.819 37.438,35.819 		"/>
+		<polygon fill="#FFFFFF" stroke="#00DF23" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.39,13.378 11.89,35.796 37.408,35.796 		"/>
+		<polygon fill="#FFFFFF" stroke="#00E024" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.391,13.403 11.917,35.769 37.379,35.769 		"/>
+		<polygon fill="#FFFFFF" stroke="#00E124" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.391,13.429 11.946,35.743 37.352,35.743 		"/>
+		<polygon fill="#FFFFFF" stroke="#00E225" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.392,13.455 11.976,35.718 37.32,35.718 		"/>
+		<polygon fill="#FFFFFF" stroke="#00E325" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.393,13.479 12.003,35.694 37.293,35.694 		"/>
+		<polygon fill="#FFFFFF" stroke="#00E426" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.393,13.504 12.033,35.669 37.264,35.669 		"/>
+		<polygon fill="#FFFFFF" stroke="#00E526" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.394,13.529 12.062,35.644 37.234,35.644 		"/>
+		<polygon fill="#FFFFFF" stroke="#00E627" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.394,13.556 12.09,35.618 37.207,35.618 		"/>
+		<polygon fill="#FFFFFF" stroke="#00E727" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.395,13.581 12.12,35.593 37.178,35.593 		"/>
+		<polygon fill="#FFFFFF" stroke="#00E828" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.396,13.605 12.147,35.567 37.148,35.567 		"/>
+		<polygon fill="#FFFFFF" stroke="#00E928" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.396,13.63 12.176,35.544 37.121,35.544 		"/>
+		<polygon fill="#FFFFFF" stroke="#00EA29" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.396,13.655 12.206,35.517 37.092,35.517 		"/>
+		<polygon fill="#FFFFFF" stroke="#00EB29" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.396,13.682 12.233,35.491 37.062,35.491 		"/>
+		<polygon fill="#FFFFFF" stroke="#00EC2A" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.397,13.707 12.263,35.466 37.035,35.466 		"/>
+		<polygon fill="#FFFFFF" stroke="#00ED2A" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.397,13.732 12.292,35.44 37.006,35.44 		"/>
+		<polygon fill="#FFFFFF" stroke="#00EE2B" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.398,13.756 12.319,35.417 36.977,35.417 		"/>
+		<polygon fill="#FFFFFF" stroke="#00EF2B" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.398,13.782 12.349,35.392 36.949,35.392 		"/>
+		<polygon fill="#FFFFFF" stroke="#00F02C" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.399,13.808 12.377,35.366 36.92,35.366 		"/>
+		<polygon fill="#FFFFFF" stroke="#00F12C" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.399,13.833 12.407,35.341 36.891,35.341 		"/>
+		<polygon fill="#FFFFFF" stroke="#00F22D" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.4,13.858 12.436,35.315 36.861,35.315 		"/>
+		<polygon fill="#FFFFFF" stroke="#00F32D" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.401,13.883 12.463,35.29 36.834,35.29 		"/>
+		<polygon fill="#FFFFFF" stroke="#00F42E" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.401,13.908 12.493,35.265 36.805,35.265 		"/>
+		<polygon fill="#FFFFFF" stroke="#00F52E" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.402,13.934 12.521,35.239 36.775,35.239 		"/>
+		<polygon fill="#FFFFFF" stroke="#00F62F" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.402,13.959 12.549,35.214 36.748,35.214 		"/>
+		<polygon fill="#FFFFFF" stroke="#00F72F" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.403,13.983 12.579,35.188 36.719,35.188 		"/>
+		<polygon fill="#FFFFFF" stroke="#00F830" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.404,14.009 12.607,35.165 36.689,35.165 		"/>
+		<polygon fill="#FFFFFF" stroke="#00F930" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.404,14.034 12.637,35.138 36.662,35.138 		"/>
+		<polygon fill="#FFFFFF" stroke="#00FA31" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.405,14.061 12.666,35.112 36.633,35.112 		"/>
+		<polygon fill="#FFFFFF" stroke="#00FB31" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.405,14.085 12.693,35.089 36.604,35.089 		"/>
+		<polygon fill="#FFFFFF" stroke="#00FC32" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.407,14.11 12.723,35.063 36.574,35.063 		"/>
+		<polygon fill="#FFFFFF" stroke="#00FD32" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.408,14.135 12.75,35.038 36.547,35.038 		"/>
+		<polygon fill="#FFFFFF" stroke="#00FE33" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" points="
+			24.408,14.16 12.779,35.013 36.518,35.013 		"/>
+		<path fill="#FFFFFF" stroke="#00FF33" stroke-width="6.6112" stroke-linecap="round" stroke-linejoin="round" d="M24.409,14.187
+			l-11.6,20.801h23.68L24.409,14.187z"/>
+	</g>
+	
+		<linearGradient id="XMLID_4_" gradientUnits="userSpaceOnUse" x1="582.6475" y1="-987.77" x2="582.6475" y2="-1015.4038" gradientTransform="matrix(1 0 0 -1 -558 -977)">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="1" style="stop-color:#00FF33"/>
+	</linearGradient>
+	<path fill="url(#XMLID_4_)" d="M39.693,34.153L26.857,12.138c-0.51-0.85-1.443-1.445-2.463-1.36c-1.021,0-1.955,0.595-2.465,1.445
+		L9.604,34.239c-0.511,0.85-0.511,1.953,0,2.805c0.51,0.852,1.444,1.359,2.465,1.359h25.16c1.021,0,1.955-0.51,2.465-1.445
+		C40.203,36.106,40.203,35.003,39.693,34.153L39.693,34.153z"/>
+	<g>
+		<path d="M24.648,33.487c-1.1,0-1.8-0.801-1.8-1.801c0-1.102,0.7-1.801,1.8-1.801c1.1,0,1.801,0.699,1.801,1.801
+			C26.449,32.687,25.748,33.487,24.648,33.487L24.648,33.487z M23.449,28.786l-0.4-9.1h3.2l-0.4,9.1H23.55H23.449z"/>
+	</g>
+</g>
+<g id="crop_x0020_marks">
+	<path fill="none" d="M48.648,48.586h-48v-48h48V48.586z"/>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/next.svg b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/next.svg
new file mode 100644
index 0000000..52b73cf
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/next.svg
@@ -0,0 +1,338 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.1" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="48" height="48" viewBox="0 0 48 48"
+	 overflow="visible" enable-background="new 0 0 48 48" xml:space="preserve">
+<g>
+	<path fill="#FFFFFF" stroke="#FFFFFF" stroke-width="7.5901" stroke-linejoin="round" d="M22.34,41.101c0,0.301,0.3,0.301,0.5,0.2
+		l16.6-16.899c0.5-0.5,0.4-0.7,0-1l-16.6-16.7c-0.1-0.1-0.4-0.1-0.4,0.1v10H8.84c-0.3,0-0.5,0.2-0.5,0.4v13.299
+		c0,0.4,0.2,0.5,0.6,0.5h13.5L22.34,41.101z"/>
+	<g>
+		<path fill="#0033CC" d="M22.34,41.101c0,0.301,0.3,0.301,0.5,0.2l16.6-16.899c0.5-0.5,0.4-0.7,0-1l-16.6-16.7
+			c-0.1-0.1-0.4-0.1-0.4,0.1v10H8.84c-0.3,0-0.5,0.2-0.5,0.4v13.299c0,0.4,0.2,0.5,0.6,0.5h13.5L22.34,41.101z"/>
+		<path fill="#0134CC" d="M22.351,41.074c0,0.3,0.3,0.3,0.5,0.2L39.427,24.4c0.5-0.499,0.4-0.699,0-0.999L22.85,6.729
+			c-0.1-0.1-0.399-0.1-0.399,0.099v9.984H8.87c-0.299,0-0.5,0.2-0.5,0.4v13.279c0,0.398,0.2,0.499,0.6,0.499H22.45L22.351,41.074z"
+			/>
+		<path fill="#0235CD" d="M22.359,41.047c0,0.3,0.299,0.3,0.499,0.2l16.553-16.848c0.5-0.498,0.399-0.697,0-0.997L22.858,6.755
+			c-0.1-0.1-0.399-0.1-0.399,0.1v9.969H8.897c-0.299,0-0.499,0.199-0.499,0.399v13.258c0,0.398,0.2,0.498,0.598,0.498h13.462
+			L22.359,41.047z"/>
+		<path fill="#0336CD" d="M22.369,41.021c0,0.301,0.299,0.301,0.498,0.199l16.53-16.82c0.498-0.498,0.397-0.696,0-0.995
+			L22.866,6.783c-0.1-0.1-0.398-0.1-0.398,0.099v9.953H8.926c-0.299,0-0.498,0.199-0.498,0.398v13.239
+			c0,0.397,0.199,0.496,0.598,0.496h13.442L22.369,41.021z"/>
+		<path fill="#0437CE" d="M22.378,40.994c0,0.299,0.298,0.299,0.497,0.198l16.506-16.794c0.496-0.497,0.397-0.695,0-0.994
+			L22.876,6.81c-0.1-0.1-0.398-0.1-0.398,0.099v9.937H8.956c-0.298,0-0.498,0.199-0.498,0.398v13.217c0,0.397,0.2,0.496,0.597,0.496
+			h13.423L22.378,40.994z"/>
+		<path fill="#0538CE" d="M22.389,40.968c0,0.299,0.298,0.299,0.496,0.198l16.483-16.769c0.496-0.496,0.397-0.694,0-0.992
+			L22.884,6.836c-0.099-0.099-0.397-0.099-0.397,0.099v9.922H8.983c-0.297,0-0.496,0.199-0.496,0.397V30.45
+			c0,0.396,0.199,0.496,0.596,0.496h13.404L22.389,40.968z"/>
+		<path fill="#0639CF" d="M22.398,40.94c0,0.299,0.298,0.299,0.496,0.199l16.46-16.742c0.495-0.496,0.396-0.694,0-0.991
+			L22.894,6.863c-0.099-0.099-0.396-0.099-0.396,0.099v9.906H9.012c-0.297,0-0.496,0.198-0.496,0.396V30.44
+			c0,0.396,0.199,0.494,0.595,0.494h13.386L22.398,40.94z"/>
+		<path fill="#073ACF" d="M22.407,40.914c0,0.298,0.298,0.298,0.495,0.198l16.437-16.716c0.494-0.495,0.396-0.692,0-0.989
+			L22.902,6.891c-0.099-0.099-0.396-0.099-0.396,0.099v9.891H9.041c-0.296,0-0.495,0.198-0.495,0.396v13.154
+			c0,0.396,0.198,0.493,0.594,0.493h13.367L22.407,40.914z"/>
+		<path fill="#083BD0" d="M22.417,40.888c0,0.297,0.297,0.297,0.495,0.198l16.413-16.689c0.494-0.494,0.396-0.691,0-0.987
+			L22.912,6.917c-0.099-0.099-0.396-0.099-0.396,0.099v9.875H9.069c-0.296,0-0.494,0.198-0.494,0.396v13.133
+			c0,0.395,0.198,0.493,0.594,0.493h13.347L22.417,40.888z"/>
+		<path fill="#093CD0" d="M22.426,40.86c0,0.297,0.296,0.297,0.493,0.197l16.39-16.662c0.492-0.494,0.395-0.69,0-0.986L22.919,6.943
+			c-0.099-0.099-0.395-0.099-0.395,0.098v9.86H9.099c-0.296,0-0.494,0.197-0.494,0.395V30.41c0,0.396,0.198,0.493,0.593,0.493
+			h13.328L22.426,40.86z"/>
+		<path fill="#0A3DD1" d="M22.437,40.834c0,0.297,0.296,0.297,0.493,0.196l16.367-16.636c0.492-0.493,0.395-0.689,0-0.984
+			L22.928,6.97c-0.099-0.099-0.394-0.099-0.394,0.098v9.844H9.127c-0.296,0-0.493,0.197-0.493,0.394v13.093
+			c0,0.395,0.197,0.492,0.592,0.492h13.309L22.437,40.834z"/>
+		<path fill="#0B3ED1" d="M22.445,40.808c0,0.297,0.296,0.297,0.492,0.197l16.343-16.61c0.492-0.492,0.395-0.688,0-0.982
+			L22.938,6.999C22.84,6.9,22.544,6.9,22.544,7.097v9.829H9.155c-0.295,0-0.493,0.196-0.493,0.394v13.072
+			c0,0.394,0.198,0.49,0.591,0.49h13.29L22.445,40.808z"/>
+		<path fill="#0C3FD2" d="M22.456,40.78c0,0.296,0.295,0.296,0.492,0.197l16.319-16.584c0.49-0.491,0.395-0.687,0-0.982
+			L22.946,7.024c-0.098-0.098-0.393-0.098-0.393,0.098v9.813H9.185c-0.294,0-0.492,0.196-0.492,0.393v13.05
+			c0,0.394,0.197,0.491,0.59,0.491h13.271L22.456,40.78z"/>
+		<path fill="#0D40D2" d="M22.464,40.754c0,0.295,0.294,0.295,0.491,0.196l16.295-16.558c0.489-0.49,0.393-0.686,0-0.98
+			L22.956,7.051c-0.099-0.098-0.393-0.098-0.393,0.097v9.797H9.212c-0.294,0-0.49,0.197-0.49,0.393v13.031
+			c0,0.393,0.196,0.489,0.588,0.489h13.252L22.464,40.754z"/>
+		<path fill="#0E41D3" d="M22.475,40.728c0,0.295,0.294,0.295,0.49,0.196l16.272-16.531c0.49-0.489,0.394-0.684,0-0.978L22.964,7.08
+			c-0.098-0.098-0.392-0.098-0.392,0.097v9.782H9.241c-0.294,0-0.49,0.196-0.49,0.392v13.01c0,0.392,0.196,0.488,0.588,0.488h13.233
+			L22.475,40.728z"/>
+		<path fill="#0F42D3" d="M22.483,40.701c0,0.294,0.294,0.294,0.49,0.194l16.248-16.504c0.488-0.488,0.393-0.683,0-0.977
+			L22.974,7.105c-0.098-0.098-0.391-0.098-0.391,0.097v9.767H9.271c-0.293,0-0.489,0.195-0.489,0.391v12.988
+			c0,0.392,0.196,0.487,0.587,0.487h13.214L22.483,40.701z"/>
+		<path fill="#1043D4" d="M22.494,40.675c0,0.293,0.294,0.293,0.489,0.194l16.226-16.478c0.487-0.488,0.392-0.683,0-0.975
+			L22.982,7.132c-0.098-0.098-0.391-0.098-0.391,0.097v9.751H9.298c-0.293,0-0.489,0.195-0.489,0.39v12.967
+			c0,0.392,0.196,0.487,0.586,0.487H22.59L22.494,40.675z"/>
+		<path fill="#1144D4" d="M22.502,40.647c0,0.293,0.293,0.293,0.488,0.194L39.191,24.39c0.487-0.487,0.392-0.682,0-0.974
+			L22.991,7.16c-0.098-0.098-0.391-0.098-0.391,0.097v9.735H9.328c-0.293,0-0.488,0.195-0.488,0.39v12.948
+			c0,0.39,0.195,0.486,0.585,0.486h13.176L22.502,40.647z"/>
+		<path fill="#1245D5" d="M22.514,40.621c0,0.292,0.292,0.292,0.487,0.194L39.177,24.39c0.488-0.486,0.392-0.68,0-0.972L23,7.188
+			c-0.098-0.098-0.39-0.098-0.39,0.096v9.72H9.356c-0.292,0-0.487,0.195-0.487,0.39v12.926c0,0.39,0.195,0.486,0.585,0.486H22.61
+			L22.514,40.621z"/>
+		<path fill="#1346D5" d="M22.522,40.595c0,0.292,0.292,0.292,0.487,0.194L39.165,24.39c0.485-0.485,0.389-0.679,0-0.97
+			L23.009,7.213c-0.098-0.097-0.389-0.097-0.389,0.097v9.704H9.384c-0.292,0-0.486,0.194-0.486,0.389V30.31
+			c0,0.389,0.195,0.484,0.584,0.484h13.138L22.522,40.595z"/>
+		<path fill="#1447D6" d="M22.531,40.567c0,0.291,0.292,0.291,0.486,0.193l16.132-16.372c0.484-0.484,0.389-0.678,0-0.969
+			L23.018,7.241c-0.097-0.097-0.389-0.097-0.389,0.097v9.688H9.414c-0.292,0-0.486,0.194-0.486,0.388v12.885
+			c0,0.388,0.195,0.483,0.583,0.483h13.118L22.531,40.567z"/>
+		<path fill="#1548D6" d="M22.542,40.541c0,0.291,0.292,0.291,0.485,0.192l16.107-16.346c0.484-0.484,0.389-0.677,0-0.968
+			L23.026,7.268c-0.097-0.097-0.388-0.097-0.388,0.097v9.672H9.441c-0.291,0-0.485,0.194-0.485,0.388v12.865
+			c0,0.388,0.194,0.483,0.582,0.483h13.099L22.542,40.541z"/>
+		<path fill="#1649D7" d="M22.551,40.515c0,0.291,0.291,0.291,0.484,0.193l16.083-16.321c0.485-0.483,0.389-0.676,0-0.966
+			L23.036,7.294c-0.097-0.097-0.388-0.097-0.388,0.096v9.657H9.47c-0.291,0-0.484,0.193-0.484,0.387v12.844
+			c0,0.387,0.194,0.481,0.582,0.481h13.08L22.551,40.515z"/>
+		<path fill="#174AD7" d="M22.561,40.487c0,0.291,0.291,0.291,0.484,0.193l16.061-16.294c0.483-0.482,0.388-0.674,0-0.964
+			L23.044,7.321c-0.097-0.096-0.387-0.096-0.387,0.097v9.641H9.5c-0.29,0-0.483,0.193-0.483,0.386v12.823
+			c0,0.387,0.193,0.481,0.58,0.481h13.062L22.561,40.487z"/>
+		<path fill="#184BD8" d="M22.57,40.462c0,0.289,0.29,0.289,0.483,0.191l16.038-16.267c0.481-0.481,0.387-0.673,0-0.962
+			L23.053,7.349c-0.097-0.096-0.387-0.096-0.387,0.096v9.626H9.527c-0.29,0-0.483,0.193-0.483,0.385v12.802
+			c0,0.386,0.193,0.481,0.58,0.481h13.042L22.57,40.462z"/>
+		<path fill="#194CD8" d="M22.58,40.435c0,0.289,0.29,0.289,0.482,0.192l16.014-16.242c0.481-0.481,0.387-0.672,0-0.961
+			L23.062,7.375c-0.097-0.096-0.386-0.096-0.386,0.096v9.611H9.557c-0.289,0-0.482,0.192-0.482,0.385v12.782
+			c0,0.384,0.193,0.479,0.579,0.479h13.023L22.58,40.435z"/>
+		<path fill="#1A4DD9" d="M22.589,40.408c0,0.288,0.289,0.288,0.482,0.192l15.99-16.216c0.48-0.48,0.386-0.672,0-0.959L23.071,7.402
+			c-0.097-0.096-0.385-0.096-0.385,0.095v9.595H9.585c-0.289,0-0.482,0.192-0.482,0.384v12.761c0,0.385,0.193,0.479,0.578,0.479
+			h13.004L22.589,40.408z"/>
+		<path fill="#1B4ED9" d="M22.6,40.382c0,0.288,0.289,0.288,0.481,0.192l15.967-16.19c0.48-0.479,0.385-0.67,0-0.958L23.081,7.43
+			c-0.096-0.096-0.384-0.096-0.384,0.095v9.58H9.614c-0.288,0-0.481,0.192-0.481,0.384v12.741c0,0.383,0.193,0.478,0.577,0.478
+			h12.985L22.6,40.382z"/>
+		<path fill="#1C4FDA" d="M22.608,40.354c0,0.289,0.289,0.289,0.48,0.192l15.943-16.164c0.479-0.478,0.386-0.669,0-0.957
+			L23.088,7.457c-0.096-0.096-0.384-0.096-0.384,0.095v9.564H9.643c-0.288,0-0.48,0.191-0.48,0.383v12.719
+			c0,0.383,0.192,0.479,0.577,0.479h12.966L22.608,40.354z"/>
+		<path fill="#1D50DA" d="M22.619,40.328c0,0.287,0.288,0.287,0.479,0.19l15.92-16.136c0.479-0.478,0.384-0.668,0-0.955
+			L23.098,7.482c-0.096-0.096-0.384-0.096-0.384,0.095v9.548H9.67c-0.288,0-0.479,0.191-0.479,0.382v12.699
+			c0,0.382,0.191,0.479,0.575,0.479h12.947L22.619,40.328z"/>
+		<path fill="#1E51DB" d="M22.628,40.302c0,0.287,0.288,0.287,0.479,0.191l15.896-16.111c0.479-0.477,0.385-0.667,0-0.954
+			L23.106,7.51c-0.096-0.096-0.383-0.096-0.383,0.094v9.533H9.699c-0.287,0-0.479,0.191-0.479,0.382v12.679
+			c0,0.382,0.191,0.477,0.575,0.477h12.928L22.628,40.302z"/>
+		<path fill="#1F52DB" d="M22.637,40.274c0,0.287,0.288,0.287,0.479,0.19L38.99,24.381c0.478-0.476,0.382-0.666,0-0.952
+			L23.115,7.538c-0.095-0.096-0.382-0.096-0.382,0.094v9.517H9.729c-0.287,0-0.478,0.191-0.478,0.381v12.657
+			c0,0.381,0.191,0.477,0.574,0.477h12.909L22.637,40.274z"/>
+		<path fill="#2053DC" d="M22.647,40.249c0,0.285,0.287,0.285,0.478,0.189l15.85-16.058c0.477-0.475,0.382-0.665,0-0.95
+			L23.125,7.563c-0.096-0.095-0.382-0.095-0.382,0.095v9.501H9.757c-0.286,0-0.478,0.19-0.478,0.381v12.636
+			c0,0.381,0.191,0.475,0.573,0.475h12.89L22.647,40.249z"/>
+		<path fill="#2154DC" d="M22.656,40.222c0,0.285,0.287,0.285,0.477,0.19L38.96,24.38c0.477-0.475,0.381-0.664,0-0.949L23.133,7.59
+			c-0.096-0.095-0.382-0.095-0.382,0.095v9.486H9.786c-0.286,0-0.477,0.19-0.477,0.38v12.617c0,0.379,0.191,0.474,0.572,0.474
+			h12.871L22.656,40.222z"/>
+		<path fill="#2255DD" d="M22.667,40.194c0,0.285,0.286,0.285,0.477,0.189l15.802-16.004c0.476-0.474,0.382-0.663,0-0.947
+			L23.143,7.618c-0.096-0.095-0.381-0.095-0.381,0.094v9.471H9.814c-0.285,0-0.476,0.189-0.476,0.379v12.596
+			c0,0.379,0.191,0.473,0.572,0.473h12.851L22.667,40.194z"/>
+		<path fill="#2356DD" d="M22.675,40.169c0,0.284,0.286,0.284,0.476,0.189l15.779-15.979c0.475-0.473,0.381-0.662,0-0.945
+			L23.151,7.645c-0.095-0.094-0.38-0.094-0.38,0.094v9.455H9.843c-0.285,0-0.475,0.189-0.475,0.378v12.574
+			c0,0.379,0.19,0.474,0.571,0.474h12.832L22.675,40.169z"/>
+		<path fill="#2457DE" d="M22.686,40.144c0,0.282,0.285,0.282,0.475,0.188l15.756-15.953c0.474-0.472,0.379-0.66,0-0.944
+			L23.159,7.671c-0.095-0.094-0.379-0.094-0.379,0.094v9.439H9.873c-0.285,0-0.475,0.189-0.475,0.378v12.554
+			c0,0.378,0.19,0.472,0.569,0.472H22.78L22.686,40.144z"/>
+		<path fill="#2558DE" d="M22.694,40.115c0,0.282,0.285,0.282,0.474,0.188l15.733-15.925c0.473-0.471,0.379-0.66,0-0.942
+			L23.168,7.698c-0.095-0.094-0.379-0.094-0.379,0.094v9.424H9.9c-0.284,0-0.474,0.189-0.474,0.377v12.535
+			c0,0.376,0.189,0.471,0.568,0.471h12.794L22.694,40.115z"/>
+		<path fill="#2659DF" d="M22.705,40.089c0,0.283,0.284,0.283,0.473,0.188l15.708-15.899c0.474-0.471,0.38-0.659,0-0.941
+			L23.177,7.726c-0.095-0.094-0.379-0.094-0.379,0.094v9.408H9.929c-0.284,0-0.473,0.188-0.473,0.377v12.514
+			c0,0.376,0.189,0.469,0.568,0.469h12.775L22.705,40.089z"/>
+		<path fill="#275ADF" d="M22.714,40.063c0,0.281,0.284,0.281,0.473,0.188l15.685-15.874c0.473-0.47,0.379-0.658,0-0.939
+			L23.188,7.752c-0.095-0.094-0.378-0.094-0.378,0.094v9.392H9.958c-0.283,0-0.472,0.188-0.472,0.376v12.492
+			c0,0.375,0.189,0.47,0.567,0.47H22.81L22.714,40.063z"/>
+		<path fill="#285BE0" d="M22.724,40.036c0,0.281,0.283,0.281,0.472,0.188l15.662-15.847c0.472-0.469,0.378-0.656,0-0.938
+			L23.195,7.779c-0.095-0.094-0.377-0.094-0.377,0.094v9.376H9.986c-0.283,0-0.472,0.188-0.472,0.375v12.472
+			c0,0.375,0.189,0.467,0.566,0.467h12.737L22.724,40.036z"/>
+		<path fill="#295CE0" d="M22.732,40.009c0,0.281,0.283,0.281,0.471,0.188l15.639-15.82c0.471-0.468,0.377-0.655,0-0.936
+			L23.205,7.807c-0.094-0.094-0.377-0.094-0.377,0.093v9.361H10.016c-0.283,0-0.471,0.188-0.471,0.375v12.451
+			c0,0.374,0.188,0.468,0.565,0.468h12.718L22.732,40.009z"/>
+		<path fill="#2A5DE1" d="M22.742,39.981c0,0.28,0.283,0.28,0.47,0.188l15.615-15.793c0.471-0.468,0.377-0.654,0-0.935L23.212,7.833
+			c-0.094-0.094-0.376-0.094-0.376,0.093v9.345H10.044c-0.282,0-0.471,0.188-0.471,0.375v12.431c0,0.374,0.188,0.467,0.565,0.467
+			h12.699L22.742,39.981z"/>
+		<path fill="#2B5EE1" d="M22.752,39.956c0,0.279,0.282,0.279,0.469,0.188l15.592-15.768c0.469-0.467,0.376-0.653,0-0.933
+			L23.223,7.86c-0.094-0.093-0.375-0.093-0.375,0.093v9.331H10.072c-0.282,0-0.47,0.187-0.47,0.373v12.41
+			c0,0.373,0.188,0.466,0.563,0.466h12.68L22.752,39.956z"/>
+		<path fill="#2C5FE2" d="M22.761,39.929c0,0.28,0.282,0.28,0.469,0.188l15.567-15.742c0.47-0.466,0.377-0.652,0-0.932L23.231,7.887
+			c-0.094-0.093-0.375-0.093-0.375,0.092v9.315H10.102c-0.281,0-0.469,0.187-0.469,0.373v12.388c0,0.372,0.188,0.465,0.563,0.465
+			h12.661L22.761,39.929z"/>
+		<path fill="#2D60E2" d="M22.771,39.901c0,0.279,0.281,0.279,0.469,0.187l15.544-15.714c0.469-0.465,0.375-0.65,0-0.93
+			L23.239,7.914c-0.094-0.093-0.375-0.093-0.375,0.093v9.299H10.129c-0.28,0-0.468,0.186-0.468,0.373v12.367
+			c0,0.372,0.188,0.465,0.562,0.465h12.642L22.771,39.901z"/>
+		<path fill="#2E61E3" d="M22.781,39.876c0,0.277,0.281,0.277,0.468,0.186l15.521-15.688c0.468-0.464,0.375-0.649,0-0.928
+			L23.25,7.94c-0.094-0.093-0.375-0.093-0.375,0.092v9.284H10.158c-0.28,0-0.467,0.186-0.467,0.372v12.347
+			c0,0.372,0.188,0.464,0.561,0.464h12.623L22.781,39.876z"/>
+		<path fill="#2F62E3" d="M22.792,39.851c0,0.277,0.28,0.277,0.467,0.186l15.499-15.663c0.466-0.464,0.373-0.649,0-0.927
+			l-15.5-15.479c-0.093-0.092-0.374-0.092-0.374,0.092v9.268H10.188c-0.28,0-0.467,0.186-0.467,0.372v12.325
+			c0,0.371,0.187,0.463,0.56,0.463h12.604L22.792,39.851z"/>
+		<path fill="#3063E4" d="M22.799,39.821c0,0.279,0.281,0.279,0.467,0.187l15.475-15.636c0.465-0.463,0.373-0.648,0-0.925
+			L23.267,7.995c-0.093-0.092-0.373-0.092-0.373,0.092v9.252H10.215c-0.279,0-0.466,0.185-0.466,0.371v12.305
+			c0,0.369,0.187,0.461,0.56,0.461h12.584L22.799,39.821z"/>
+		<path fill="#3164E4" d="M22.81,39.796c0,0.277,0.28,0.277,0.466,0.186l15.451-15.61c0.465-0.462,0.372-0.646,0-0.924L23.275,8.021
+			c-0.094-0.092-0.373-0.092-0.373,0.092v9.237H10.245c-0.279,0-0.465,0.185-0.465,0.37v12.285c0,0.369,0.187,0.461,0.559,0.461
+			h12.565L22.81,39.796z"/>
+		<path fill="#3265E5" d="M22.819,39.771c0,0.276,0.279,0.276,0.465,0.185l15.428-15.583c0.465-0.461,0.373-0.646,0-0.922
+			L23.284,8.048c-0.093-0.092-0.372-0.092-0.372,0.092v9.221H10.273c-0.279,0-0.464,0.185-0.464,0.37v12.265
+			c0,0.369,0.186,0.46,0.558,0.46h12.546L22.819,39.771z"/>
+		<path fill="#3366E5" d="M22.83,39.743c0,0.275,0.278,0.275,0.464,0.185l15.404-15.557c0.464-0.46,0.371-0.645,0-0.921
+			L23.293,8.076c-0.093-0.092-0.372-0.092-0.372,0.092v9.206h-12.62c-0.278,0-0.464,0.184-0.464,0.369v12.243
+			c0,0.369,0.186,0.461,0.557,0.461h12.527L22.83,39.743z"/>
+		<path fill="#3366E6" d="M22.838,39.716c0,0.276,0.278,0.276,0.464,0.186l15.38-15.532c0.463-0.459,0.371-0.643,0-0.918
+			L23.302,8.103c-0.093-0.092-0.371-0.092-0.371,0.091v9.19H10.331c-0.278,0-0.463,0.185-0.463,0.368v12.222
+			c0,0.368,0.186,0.459,0.556,0.459h12.508L22.838,39.716z"/>
+		<path fill="#3467E6" d="M22.849,39.688c0,0.275,0.278,0.275,0.463,0.185l15.357-15.504c0.461-0.458,0.369-0.642,0-0.917
+			L23.312,8.129C23.217,8.038,22.94,8.038,22.94,8.22v9.174H10.358c-0.277,0-0.462,0.184-0.462,0.368v12.203
+			c0,0.366,0.185,0.458,0.555,0.458H22.94L22.849,39.688z"/>
+		<path fill="#3568E7" d="M22.857,39.663c0,0.275,0.277,0.275,0.462,0.184l15.333-15.478c0.461-0.458,0.37-0.641,0-0.916
+			L23.319,8.156c-0.093-0.092-0.37-0.092-0.37,0.091v9.159H10.387c-0.277,0-0.461,0.184-0.461,0.367v12.182
+			c0,0.366,0.185,0.457,0.554,0.457h12.47L22.857,39.663z"/>
+		<path fill="#3669E7" d="M22.867,39.637c0,0.274,0.277,0.274,0.461,0.183l15.31-15.452c0.461-0.458,0.368-0.64,0-0.915
+			l-15.31-15.27c-0.092-0.091-0.369-0.091-0.369,0.091v9.143H10.417c-0.277,0-0.461,0.184-0.461,0.366v12.16
+			c0,0.365,0.184,0.457,0.553,0.457h12.451L22.867,39.637z"/>
+		<path fill="#376AE8" d="M22.877,39.608c0,0.274,0.276,0.274,0.46,0.184l15.287-15.425c0.461-0.457,0.369-0.639,0-0.913
+			L23.337,8.21c-0.092-0.091-0.368-0.091-0.368,0.091v9.127H10.445c-0.276,0-0.46,0.183-0.46,0.366v12.14
+			c0,0.365,0.184,0.455,0.552,0.455h12.432L22.877,39.608z"/>
+		<path fill="#386BE8" d="M22.886,39.583c0,0.273,0.276,0.273,0.46,0.184l15.263-15.4c0.459-0.456,0.368-0.638,0-0.911L23.347,8.237
+			c-0.092-0.091-0.368-0.091-0.368,0.091v9.112H10.474c-0.275,0-0.459,0.183-0.459,0.365v12.119c0,0.363,0.184,0.454,0.552,0.454
+			h12.413L22.886,39.583z"/>
+		<path fill="#396CE9" d="M22.896,39.558c0,0.272,0.276,0.272,0.459,0.182l15.239-15.374c0.459-0.455,0.367-0.637,0-0.91
+			L23.355,8.265c-0.092-0.091-0.368-0.091-0.368,0.09v9.097H10.502c-0.275,0-0.459,0.183-0.459,0.364v12.099
+			c0,0.364,0.184,0.454,0.551,0.454h12.394L22.896,39.558z"/>
+		<path fill="#3A6DE9" d="M22.905,39.528c0,0.273,0.276,0.273,0.459,0.184l15.217-15.348c0.457-0.454,0.366-0.635,0-0.908
+			L23.364,8.292c-0.092-0.091-0.367-0.091-0.367,0.09v9.081H10.531c-0.275,0-0.458,0.182-0.458,0.364v12.079
+			c0,0.361,0.184,0.453,0.55,0.453h12.374L22.905,39.528z"/>
+		<path fill="#3B6EEA" d="M22.916,39.503c0,0.271,0.275,0.271,0.458,0.182l15.193-15.32c0.456-0.453,0.366-0.634,0-0.906
+			L23.374,8.318c-0.092-0.091-0.366-0.091-0.366,0.09v9.065H10.56c-0.274,0-0.458,0.182-0.458,0.363v12.057
+			c0,0.362,0.183,0.453,0.549,0.453h12.355L22.916,39.503z"/>
+		<path fill="#3C6FEA" d="M22.924,39.478c0,0.271,0.274,0.271,0.457,0.181l15.17-15.294c0.455-0.453,0.365-0.633,0-0.905
+			L23.381,8.344c-0.092-0.09-0.366-0.09-0.366,0.09v9.05H10.588c-0.274,0-0.457,0.181-0.457,0.363v12.036
+			c0,0.361,0.183,0.451,0.548,0.451h12.336L22.924,39.478z"/>
+		<path fill="#3D70EB" d="M22.935,39.45c0,0.271,0.274,0.271,0.456,0.181l15.146-15.269c0.455-0.452,0.365-0.632,0-0.904
+			L23.391,8.373c-0.091-0.09-0.365-0.09-0.365,0.09v9.034H10.617c-0.274,0-0.456,0.181-0.456,0.362v12.017
+			c0,0.36,0.182,0.45,0.547,0.45h12.317L22.935,39.45z"/>
+		<path fill="#3E71EB" d="M22.943,39.424c0,0.271,0.274,0.271,0.456,0.181l15.123-15.243c0.455-0.451,0.363-0.631,0-0.902
+			L23.399,8.398c-0.091-0.09-0.365-0.09-0.365,0.09v9.019h-12.39c-0.273,0-0.455,0.181-0.455,0.361v11.994
+			c0,0.361,0.182,0.451,0.546,0.451h12.298L22.943,39.424z"/>
+		<path fill="#3F72EC" d="M22.954,39.397c0,0.271,0.273,0.271,0.455,0.181l15.099-15.217c0.455-0.45,0.365-0.63,0-0.9L23.408,8.425
+			c-0.091-0.09-0.364-0.09-0.364,0.089v9.003h-12.37c-0.272,0-0.455,0.18-0.455,0.361v11.974c0,0.359,0.182,0.449,0.546,0.449
+			h12.279L22.954,39.397z"/>
+		<path fill="#4073EC" d="M22.962,39.37c0,0.27,0.273,0.27,0.455,0.18l15.076-15.188c0.453-0.45,0.363-0.629,0-0.898L23.417,8.453
+			c-0.091-0.09-0.363-0.09-0.363,0.089v8.988H10.704c-0.272,0-0.454,0.18-0.454,0.36v11.954c0,0.358,0.182,0.448,0.545,0.448h12.26
+			L22.962,39.37z"/>
+		<path fill="#4174ED" d="M22.973,39.344c0,0.271,0.272,0.271,0.454,0.181L38.479,24.36c0.452-0.449,0.362-0.628,0-0.897
+			L23.426,8.48c-0.091-0.09-0.363-0.09-0.363,0.089v8.972H10.731c-0.272,0-0.453,0.18-0.453,0.359v11.933
+			c0,0.357,0.181,0.447,0.544,0.447h12.241L22.973,39.344z"/>
+		<path fill="#4275ED" d="M22.982,39.315c0,0.271,0.272,0.271,0.453,0.181l15.028-15.137c0.453-0.448,0.363-0.626,0-0.896
+			L23.436,8.506c-0.091-0.09-0.362-0.09-0.362,0.089v8.957H10.76c-0.271,0-0.453,0.18-0.453,0.358v11.913
+			c0,0.357,0.181,0.445,0.543,0.445h12.222L22.982,39.315z"/>
+		<path fill="#4376EE" d="M22.991,39.29c0,0.27,0.272,0.27,0.453,0.179l15.005-15.109c0.451-0.447,0.362-0.625,0-0.894L23.444,8.534
+			c-0.091-0.089-0.362-0.089-0.362,0.089v8.94H10.79c-0.271,0-0.452,0.18-0.452,0.358v11.893c0,0.355,0.181,0.444,0.542,0.444
+			h12.203L22.991,39.29z"/>
+		<path fill="#4477EE" d="M23.001,39.265c0,0.268,0.271,0.268,0.452,0.178l14.981-15.083c0.449-0.446,0.361-0.625,0-0.893
+			L23.454,8.561c-0.091-0.089-0.361-0.089-0.361,0.089v8.925H10.817c-0.271,0-0.451,0.179-0.451,0.357v11.87
+			c0,0.356,0.181,0.445,0.542,0.445h12.184L23.001,39.265z"/>
+		<path fill="#4578EF" d="M23.01,39.237c0,0.268,0.271,0.268,0.451,0.178l14.959-15.058c0.449-0.445,0.359-0.624,0-0.891
+			L23.461,8.587c-0.09-0.089-0.361-0.089-0.361,0.089v8.91H10.847c-0.27,0-0.45,0.179-0.45,0.356v11.851
+			c0,0.354,0.18,0.444,0.541,0.444h12.165L23.01,39.237z"/>
+		<path fill="#4679EF" d="M23.021,39.21c0,0.268,0.271,0.268,0.45,0.18l14.935-15.032c0.449-0.445,0.36-0.623,0-0.889L23.47,8.614
+			c-0.09-0.089-0.36-0.089-0.36,0.089v8.894H10.875c-0.27,0-0.45,0.179-0.45,0.356v11.83c0,0.354,0.18,0.444,0.54,0.444H23.11
+			L23.021,39.21z"/>
+		<path fill="#477AF0" d="M23.03,39.185c0,0.267,0.27,0.267,0.449,0.178l14.912-15.005c0.447-0.444,0.359-0.622,0-0.888
+			L23.479,8.642c-0.09-0.089-0.359-0.089-0.359,0.088v8.878H10.903c-0.27,0-0.449,0.178-0.449,0.356v11.809
+			c0,0.354,0.18,0.441,0.539,0.441h12.127L23.03,39.185z"/>
+		<path fill="#487BF0" d="M23.041,39.157c0,0.266,0.269,0.266,0.448,0.177l14.89-14.979c0.446-0.443,0.357-0.62,0-0.886
+			L23.488,8.668c-0.09-0.089-0.359-0.089-0.359,0.088v8.863H10.933c-0.269,0-0.448,0.177-0.448,0.354v11.788
+			c0,0.354,0.179,0.441,0.538,0.441h12.107L23.041,39.157z"/>
+		<path fill="#497CF1" d="M23.049,39.13c0,0.268,0.269,0.268,0.448,0.178l14.865-14.952c0.446-0.442,0.357-0.619,0-0.885
+			L23.498,8.695c-0.09-0.088-0.358-0.088-0.358,0.088v8.848H10.961c-0.269,0-0.448,0.177-0.448,0.354v11.767
+			c0,0.354,0.179,0.44,0.538,0.44H23.14L23.049,39.13z"/>
+		<path fill="#4A7DF1" d="M23.06,39.104c0,0.266,0.269,0.266,0.447,0.176l14.841-14.925c0.446-0.442,0.356-0.618,0-0.883
+			L23.506,8.723c-0.09-0.088-0.358-0.088-0.358,0.088v8.832H10.989c-0.268,0-0.447,0.177-0.447,0.354v11.747
+			c0,0.354,0.179,0.439,0.537,0.439h12.069L23.06,39.104z"/>
+		<path fill="#4B7EF2" d="M23.068,39.077c0,0.265,0.269,0.265,0.447,0.177l14.817-14.899c0.445-0.441,0.357-0.617,0-0.882
+			L23.516,8.75c-0.09-0.088-0.357-0.088-0.357,0.088v8.816h-12.14c-0.268,0-0.446,0.177-0.446,0.354v11.726
+			c0,0.353,0.179,0.439,0.536,0.439h12.05L23.068,39.077z"/>
+		<path fill="#4C7FF2" d="M23.079,39.051c0,0.265,0.268,0.265,0.446,0.177l14.794-14.874c0.444-0.44,0.356-0.616,0-0.88
+			L23.523,8.775c-0.089-0.088-0.357-0.088-0.357,0.088v8.8h-12.12c-0.268,0-0.446,0.176-0.446,0.353v11.705
+			c0,0.353,0.178,0.439,0.535,0.439h12.031L23.079,39.051z"/>
+		<path fill="#4D80F3" d="M23.087,39.024c0,0.264,0.268,0.264,0.445,0.176l14.771-14.848c0.443-0.439,0.355-0.615,0-0.878
+			L23.532,8.803c-0.089-0.088-0.356-0.088-0.356,0.087v8.785H11.075c-0.267,0-0.445,0.176-0.445,0.352v11.685
+			c0,0.352,0.178,0.438,0.534,0.438h12.012L23.087,39.024z"/>
+		<path fill="#4E81F3" d="M23.098,38.997c0,0.264,0.267,0.264,0.445,0.176l14.748-14.82c0.442-0.438,0.354-0.614,0-0.877
+			L23.542,8.831c-0.089-0.088-0.356-0.088-0.356,0.087v8.769H11.104c-0.266,0-0.444,0.176-0.444,0.352v11.665
+			c0,0.35,0.178,0.437,0.533,0.437h11.993L23.098,38.997z"/>
+		<path fill="#4F82F4" d="M23.107,38.972c0,0.262,0.267,0.262,0.444,0.174l14.723-14.794c0.441-0.438,0.355-0.613,0-0.875
+			L23.55,8.856c-0.089-0.087-0.355-0.087-0.355,0.087v8.754H11.132c-0.266,0-0.443,0.176-0.443,0.351V29.69
+			c0,0.351,0.177,0.438,0.532,0.438h11.974L23.107,38.972z"/>
+		<path fill="#5083F4" d="M23.116,38.944c0,0.262,0.266,0.262,0.443,0.175l14.699-14.769c0.443-0.437,0.354-0.611,0-0.874
+			L23.56,8.883c-0.089-0.087-0.354-0.087-0.354,0.087v8.738H11.162c-0.266,0-0.443,0.175-0.443,0.35v11.622
+			c0,0.35,0.177,0.437,0.531,0.437h11.955L23.116,38.944z"/>
+		<path fill="#5184F5" d="M23.126,38.918c0,0.263,0.266,0.263,0.442,0.174l14.677-14.741c0.441-0.436,0.354-0.61,0-0.872
+			L23.568,8.911c-0.089-0.087-0.354-0.087-0.354,0.087v8.723H11.19c-0.265,0-0.442,0.175-0.442,0.35v11.603
+			c0,0.348,0.177,0.436,0.531,0.436h11.936L23.126,38.918z"/>
+		<path fill="#5285F5" d="M23.135,38.892c0,0.262,0.266,0.262,0.442,0.174L38.23,24.35c0.44-0.436,0.354-0.609,0-0.871L23.578,8.938
+			c-0.088-0.087-0.354-0.087-0.354,0.087v8.707H11.218c-0.265,0-0.441,0.175-0.441,0.349v11.581c0,0.348,0.177,0.434,0.53,0.434
+			h11.917L23.135,38.892z"/>
+		<path fill="#5386F6" d="M23.146,38.864c0,0.261,0.265,0.261,0.441,0.174l14.629-14.689c0.44-0.435,0.354-0.608,0-0.869
+			L23.586,8.964c-0.088-0.087-0.353-0.087-0.353,0.086v8.691H11.248c-0.264,0-0.441,0.174-0.441,0.348v11.562
+			c0,0.347,0.177,0.433,0.529,0.433h11.898L23.146,38.864z"/>
+		<path fill="#5487F6" d="M23.154,38.838c0,0.261,0.264,0.261,0.44,0.174l14.608-14.663c0.438-0.434,0.352-0.607,0-0.867
+			L23.595,8.992c-0.088-0.087-0.353-0.087-0.353,0.086v8.676H11.276c-0.264,0-0.44,0.174-0.44,0.348v11.54
+			c0,0.346,0.176,0.433,0.528,0.433h11.878L23.154,38.838z"/>
+		<path fill="#5588F7" d="M23.165,38.812c0,0.26,0.264,0.26,0.44,0.174l14.583-14.637c0.438-0.433,0.353-0.606,0-0.866L23.604,9.019
+			c-0.088-0.086-0.352-0.086-0.352,0.086v8.661H11.304c-0.263,0-0.439,0.173-0.439,0.347v11.52c0,0.346,0.176,0.432,0.527,0.432
+			h11.859L23.165,38.812z"/>
+		<path fill="#5689F7" d="M23.173,38.784c0,0.26,0.264,0.26,0.439,0.173l14.561-14.609c0.438-0.433,0.351-0.605,0-0.865
+			L23.612,9.045c-0.088-0.086-0.351-0.086-0.351,0.086v8.645H11.333c-0.263,0-0.438,0.173-0.438,0.346v11.499
+			c0,0.345,0.175,0.431,0.526,0.431h11.84L23.173,38.784z"/>
+		<path fill="#578AF8" d="M23.184,38.758c0,0.259,0.263,0.259,0.438,0.173l14.537-14.584c0.437-0.432,0.351-0.604,0-0.863
+			L23.622,9.072c-0.088-0.086-0.351-0.086-0.351,0.086v8.629H11.362c-0.263,0-0.438,0.173-0.438,0.346V29.61
+			c0,0.346,0.175,0.432,0.525,0.432h11.821L23.184,38.758z"/>
+		<path fill="#588BF8" d="M23.192,38.731c0,0.258,0.263,0.258,0.438,0.172l14.513-14.558c0.436-0.431,0.35-0.603,0-0.861L23.63,9.1
+			c-0.087-0.086-0.35-0.086-0.35,0.086v8.614h-11.89c-0.262,0-0.437,0.173-0.437,0.345v11.456c0,0.344,0.175,0.43,0.524,0.43H23.28
+			L23.192,38.731z"/>
+		<path fill="#598CF9" d="M23.203,38.704c0,0.259,0.262,0.259,0.437,0.173l14.488-14.532c0.437-0.43,0.351-0.602,0-0.86L23.64,9.126
+			c-0.088-0.086-0.35-0.086-0.35,0.085v8.598h-11.87c-0.262,0-0.437,0.172-0.437,0.344v11.438c0,0.344,0.175,0.428,0.524,0.428
+			h11.784L23.203,38.704z"/>
+		<path fill="#5A8DF9" d="M23.212,38.678c0,0.259,0.262,0.259,0.436,0.173l14.466-14.506c0.436-0.429,0.35-0.6,0-0.858L23.648,9.153
+			c-0.088-0.086-0.349-0.086-0.349,0.085v8.583H11.448c-0.262,0-0.436,0.172-0.436,0.344v11.416c0,0.343,0.174,0.428,0.523,0.428
+			h11.764L23.212,38.678z"/>
+		<path fill="#5B8EFA" d="M23.222,38.651c0,0.257,0.262,0.257,0.436,0.17L38.1,24.343c0.434-0.428,0.349-0.599,0-0.856L23.657,9.181
+			c-0.087-0.085-0.349-0.085-0.349,0.085v8.567H11.477c-0.261,0-0.435,0.171-0.435,0.343v11.394c0,0.343,0.174,0.428,0.522,0.428
+			h11.745L23.222,38.651z"/>
+		<path fill="#5C8FFA" d="M23.231,38.625c0,0.256,0.261,0.256,0.435,0.171l14.418-14.453c0.435-0.428,0.349-0.598,0-0.855
+			L23.667,9.208c-0.087-0.085-0.348-0.085-0.348,0.085v8.551H11.505c-0.261,0-0.434,0.172-0.434,0.343v11.375
+			c0,0.34,0.173,0.426,0.521,0.426h11.726L23.231,38.625z"/>
+		<path fill="#5D90FB" d="M23.24,38.599c0,0.256,0.261,0.256,0.434,0.17L38.07,24.342c0.433-0.427,0.349-0.598,0-0.854L23.674,9.233
+			c-0.087-0.085-0.347-0.085-0.347,0.085v8.536H11.534c-0.26,0-0.434,0.171-0.434,0.342V29.55c0,0.342,0.173,0.426,0.52,0.426
+			h11.707L23.24,38.599z"/>
+		<path fill="#5E91FB" d="M23.25,38.571c0,0.256,0.26,0.256,0.434,0.171l14.371-14.401c0.432-0.426,0.347-0.596,0-0.852
+			L23.685,9.261c-0.087-0.085-0.347-0.085-0.347,0.084v8.521H11.562c-0.259,0-0.433,0.171-0.433,0.342V29.54
+			c0,0.34,0.173,0.424,0.52,0.424h11.688L23.25,38.571z"/>
+		<path fill="#5F92FC" d="M23.26,38.545c0,0.255,0.26,0.255,0.433,0.17l14.349-14.374c0.432-0.425,0.347-0.595,0-0.85L23.692,9.289
+			c-0.087-0.085-0.346-0.085-0.346,0.084v8.504H11.591c-0.259,0-0.432,0.171-0.432,0.341V29.53c0,0.339,0.173,0.423,0.519,0.423
+			h11.669L23.26,38.545z"/>
+		<path fill="#6093FC" d="M23.27,38.519c0,0.254,0.259,0.254,0.432,0.17l14.326-14.347c0.431-0.425,0.345-0.594,0-0.849
+			L23.702,9.314c-0.087-0.085-0.346-0.085-0.346,0.084v8.489H11.621c-0.259,0-0.432,0.17-0.432,0.34v11.291
+			c0,0.34,0.173,0.424,0.518,0.424h11.649L23.27,38.519z"/>
+		<path fill="#6194FD" d="M23.279,38.491c0,0.255,0.259,0.255,0.431,0.17l14.302-14.322c0.429-0.424,0.345-0.593,0-0.847
+			L23.71,9.341c-0.086-0.084-0.345-0.084-0.345,0.084v8.473H11.648c-0.259,0-0.431,0.17-0.431,0.34v11.271
+			c0,0.338,0.172,0.422,0.517,0.422h11.63L23.279,38.491z"/>
+		<path fill="#6295FD" d="M23.29,38.465c0,0.254,0.258,0.254,0.43,0.169l14.28-14.294c0.428-0.423,0.344-0.592,0-0.846L23.719,9.369
+			c-0.086-0.084-0.344-0.084-0.344,0.084v8.458H11.677c-0.258,0-0.43,0.17-0.43,0.339v11.25c0,0.338,0.172,0.422,0.516,0.422h11.612
+			L23.29,38.465z"/>
+		<path fill="#6396FE" d="M23.298,38.438c0,0.254,0.258,0.254,0.43,0.17l14.255-14.269c0.428-0.422,0.344-0.591,0-0.844
+			l-14.255-14.1c-0.086-0.084-0.344-0.084-0.344,0.084v8.442H11.707c-0.258,0-0.429,0.169-0.429,0.338v11.228
+			c0,0.338,0.171,0.422,0.515,0.422h11.592L23.298,38.438z"/>
+		<path fill="#6497FE" d="M23.309,38.412c0,0.253,0.257,0.253,0.429,0.168l14.23-14.242c0.428-0.422,0.344-0.59,0-0.843
+			L23.737,9.422c-0.086-0.084-0.344-0.084-0.344,0.083v8.427H11.734c-0.257,0-0.429,0.169-0.429,0.338v11.209
+			c0,0.336,0.171,0.418,0.514,0.418h11.573L23.309,38.412z"/>
+		<path fill="#6598FF" d="M23.317,38.385c0,0.253,0.257,0.253,0.429,0.169l14.208-14.216c0.428-0.42,0.344-0.588,0-0.841
+			L23.747,9.45c-0.086-0.084-0.343-0.084-0.343,0.083v8.411h-11.64c-0.257,0-0.428,0.169-0.428,0.337v11.188
+			c0,0.336,0.171,0.419,0.514,0.419h11.554L23.317,38.385z"/>
+		<path fill="#6699FF" d="M23.328,38.358c0,0.252,0.257,0.252,0.428,0.168l14.185-14.19c0.426-0.42,0.342-0.587,0-0.839
+			L23.754,9.477c-0.086-0.084-0.342-0.084-0.342,0.083v8.396h-11.62c-0.256,0-0.427,0.168-0.427,0.336v11.167
+			c0,0.335,0.171,0.418,0.513,0.418h11.535L23.328,38.358z"/>
+	</g>
+	
+		<linearGradient id="XMLID_10_" gradientUnits="userSpaceOnUse" x1="210.7969" y1="-239.4214" x2="210.7969" y2="-268.5771" gradientTransform="matrix(1 0 0 -1 -186 -230)">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="1" style="stop-color:#6699FF"/>
+	</linearGradient>
+	<path fill="url(#XMLID_10_)" d="M23.328,38.358c0,0.252,0.257,0.252,0.428,0.168l14.185-14.19c0.426-0.42,0.342-0.587,0-0.839
+		L23.754,9.477c-0.086-0.084-0.342-0.084-0.342,0.083v8.396h-11.62c-0.256,0-0.427,0.168-0.427,0.336v11.167
+		c0,0.335,0.171,0.418,0.513,0.418h11.535L23.328,38.358z"/>
+</g>
+<g id="crop_x0020_marks">
+	<path fill="none" d="M48.06,47.999h-48v-48h48V47.999z"/>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/note.svg b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/note.svg
new file mode 100644
index 0000000..e94c610
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/note.svg
@@ -0,0 +1,200 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.1" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="25.5" height="25.5" viewBox="0 0 25.5 25.5"
+	 overflow="visible" enable-background="new 0 0 25.5 25.5" xml:space="preserve">
+<g id="Layer_x0020_1">
+	<g>
+		<path fill="#1F60A9" d="M25.5,12.7c0,7-5.7,12.7-12.7,12.7C5.7,25.5,0,19.8,0,12.7C0,5.6,5.7,0,12.7,0s12.7,5.7,12.7,12.7H25.5z"
+			/>
+		<path fill="#2060AA" d="M25.473,12.7c0,6.983-5.688,12.671-12.672,12.671C5.718,25.471,0.03,19.783,0.03,12.7
+			S5.718,0.029,12.701,0.029c6.984,0,12.671,5.687,12.671,12.671H25.473z"/>
+		<path fill="#2160AB" d="M25.443,12.7c0,6.968-5.674,12.642-12.643,12.642C5.734,25.439,0.061,19.768,0.061,12.7
+			c0-7.068,5.674-12.642,12.642-12.642c6.968,0,12.641,5.674,12.641,12.642H25.443z"/>
+		<path fill="#2160AC" d="M25.415,12.7c0,6.95-5.661,12.612-12.612,12.612C5.752,25.412,0.091,19.751,0.091,12.7
+			c0-7.051,5.661-12.612,12.612-12.612S25.316,5.749,25.316,12.7H25.415z"/>
+		<path fill="#2260AD" d="M25.387,12.7c0,6.936-5.648,12.583-12.583,12.583C5.769,25.383,0.121,19.734,0.121,12.7
+			c0-7.035,5.648-12.583,12.583-12.583c6.937,0,12.583,5.648,12.583,12.583H25.387z"/>
+		<path fill="#2360AE" d="M25.357,12.701c0,6.919-5.635,12.554-12.553,12.554C5.787,25.354,0.152,19.719,0.152,12.701
+			c0-7.019,5.635-12.554,12.554-12.554S25.26,5.782,25.26,12.701H25.357z"/>
+		<path fill="#2460AF" d="M25.33,12.7c0,6.903-5.622,12.524-12.525,12.524C5.803,25.323,0.181,19.702,0.181,12.7
+			S5.803,0.175,12.706,0.175c6.903,0,12.524,5.621,12.524,12.525H25.33z"/>
+		<path fill="#2560B0" d="M25.302,12.701c0,6.887-5.608,12.496-12.496,12.496C5.82,25.294,0.212,19.686,0.212,12.701
+			c0-6.986,5.608-12.496,12.496-12.496c6.888,0,12.496,5.608,12.496,12.496H25.302z"/>
+		<path fill="#2661B1" d="M25.273,12.7c0,6.87-5.597,12.467-12.467,12.467C5.837,25.266,0.242,19.67,0.242,12.7
+			c0-6.969,5.595-12.467,12.467-12.467c6.871,0,12.467,5.596,12.467,12.467H25.273z"/>
+		<path fill="#2661B2" d="M25.245,12.7c0,6.854-5.583,12.438-12.438,12.438C5.854,25.234,0.272,19.652,0.272,12.7
+			S5.854,0.262,12.709,0.262c6.855,0,12.438,5.583,12.438,12.438H25.245z"/>
+		<path fill="#2761B3" d="M25.216,12.7c0,6.839-5.567,12.407-12.408,12.407C5.872,25.205,0.303,19.637,0.303,12.7
+			c0-6.937,5.569-12.408,12.408-12.408S25.12,5.861,25.12,12.7H25.216z"/>
+		<path fill="#2861B4" d="M25.188,12.7c0,6.823-5.557,12.38-12.378,12.38C5.889,25.177,0.333,19.62,0.333,12.7
+			c0-6.92,5.556-12.379,12.379-12.379c6.823,0,12.38,5.556,12.38,12.379H25.188z"/>
+		<path fill="#2961B5" d="M25.16,12.7c0,6.807-5.543,12.35-12.351,12.35C5.906,25.146,0.363,19.604,0.363,12.7
+			c0-6.904,5.543-12.35,12.35-12.35s12.35,5.543,12.35,12.35H25.16z"/>
+		<path fill="#2A61B6" d="M25.131,12.7c0,6.792-5.529,12.321-12.32,12.321C5.923,25.117,0.393,19.588,0.393,12.7
+			c0-6.888,5.53-12.32,12.321-12.32s12.32,5.53,12.32,12.32H25.131z"/>
+		<path fill="#2A61B7" d="M25.104,12.7c0,6.774-5.518,12.292-12.292,12.292C5.94,25.088,0.424,19.57,0.424,12.7
+			c0-6.872,5.517-12.292,12.291-12.292c6.773,0,12.292,5.517,12.292,12.292H25.104z"/>
+		<path fill="#2B61B8" d="M25.075,12.7c0,6.759-5.505,12.263-12.263,12.263C5.958,25.059,0.455,19.555,0.455,12.7
+			c0-6.855,5.503-12.262,12.262-12.262c6.76,0,12.262,5.504,12.262,12.262H25.075z"/>
+		<path fill="#2C61B9" d="M25.046,12.7c0,6.743-5.489,12.233-12.232,12.233C5.975,25.029,0.484,19.539,0.484,12.7
+			c0-6.839,5.491-12.233,12.233-12.233c6.743,0,12.233,5.491,12.233,12.233H25.046z"/>
+		<path fill="#2D61BA" d="M25.018,12.7c0,6.727-5.478,12.204-12.204,12.204C5.992,25,0.514,19.521,0.514,12.7
+			c0-6.822,5.478-12.204,12.204-12.204S24.922,5.973,24.922,12.7H25.018z"/>
+		<path fill="#2E61BB" d="M24.988,12.7c0,6.711-5.463,12.175-12.173,12.175C6.009,24.971,0.544,19.506,0.544,12.7
+			c0-6.807,5.464-12.175,12.175-12.175S24.895,5.99,24.895,12.7H24.988z"/>
+		<path fill="#2F61BC" d="M24.962,12.701c0,6.693-5.45,12.145-12.146,12.145C6.026,24.941,0.575,19.49,0.575,12.701
+			c0-6.79,5.451-12.146,12.146-12.146c6.695,0,12.146,5.452,12.146,12.146H24.962z"/>
+		<path fill="#2F61BD" d="M24.934,12.7c0,6.678-5.438,12.116-12.117,12.116C6.043,24.911,0.605,19.475,0.605,12.7
+			S6.043,0.584,12.722,0.584c6.678,0,12.116,5.438,12.116,12.116H24.934z"/>
+		<path fill="#3061BE" d="M24.904,12.7c0,6.661-5.426,12.087-12.087,12.087C6.06,24.882,0.635,19.457,0.635,12.7
+			c0-6.757,5.425-12.087,12.087-12.087c6.661,0,12.086,5.425,12.086,12.087H24.904z"/>
+		<path fill="#3162BF" d="M24.876,12.7c0,6.646-5.412,12.059-12.058,12.059C6.078,24.854,0.666,19.439,0.666,12.7
+			c0-6.741,5.412-12.058,12.058-12.058S24.783,6.054,24.783,12.7H24.876z"/>
+		<path fill="#3262C0" d="M24.85,12.701c0,6.63-5.399,12.027-12.03,12.027C6.095,24.823,0.696,19.425,0.696,12.701
+			c0-6.725,5.399-12.029,12.029-12.029c6.628,0,12.028,5.399,12.028,12.029H24.85z"/>
+		<path fill="#3362C1" d="M24.818,12.7c0,6.614-5.385,11.999-12,11.999C6.112,24.794,0.727,19.408,0.727,12.7s5.385-12,12-12
+			c6.614,0,12,5.386,12,12H24.818z"/>
+		<path fill="#3362C2" d="M24.791,12.7c0,6.598-5.373,11.97-11.971,11.97C6.129,24.764,0.756,19.393,0.756,12.7
+			S6.129,0.73,12.727,0.73c6.597,0,11.968,5.372,11.968,11.97H24.791z"/>
+		<path fill="#3462C3" d="M24.764,12.7c0,6.582-5.359,11.94-11.942,11.94C6.146,24.734,0.787,19.375,0.787,12.7
+			c0-6.676,5.359-11.941,11.941-11.941c6.583,0,11.941,5.36,11.941,11.941H24.764z"/>
+		<path fill="#3562C4" d="M24.734,12.7c0,6.565-5.348,11.911-11.913,11.911C6.164,24.705,0.817,19.359,0.817,12.7
+			S6.164,0.788,12.729,0.788c6.566,0,11.912,5.347,11.912,11.912H24.734z"/>
+		<path fill="#3662C5" d="M24.706,12.7c0,6.55-5.333,11.883-11.883,11.883C6.181,24.676,0.847,19.343,0.847,12.7
+			c0-6.643,5.333-11.883,11.883-11.883c6.549,0,11.881,5.333,11.881,11.883H24.706z"/>
+		<path fill="#3762C6" d="M24.678,12.7c0,6.534-5.32,11.854-11.854,11.854C6.198,24.646,0.877,19.326,0.877,12.7
+			S6.198,0.846,12.731,0.846c6.535,0,11.853,5.32,11.853,11.854H24.678z"/>
+		<path fill="#3762C7" d="M24.648,12.7c0,6.518-5.308,11.823-11.824,11.823C6.215,24.617,0.908,19.311,0.908,12.7
+			c0-6.611,5.307-11.824,11.824-11.824S24.557,6.183,24.557,12.7H24.648z"/>
+		<path fill="#3862C8" d="M24.621,12.7c0,6.502-5.294,11.795-11.795,11.795C6.232,24.588,0.938,19.294,0.938,12.7
+			c0-6.594,5.293-11.795,11.795-11.795c6.501,0,11.794,5.294,11.794,11.795H24.621z"/>
+		<path fill="#3962C9" d="M24.593,12.7c0,6.485-5.28,11.766-11.766,11.766C6.249,24.559,0.968,19.277,0.968,12.7
+			c0-6.578,5.281-11.766,11.766-11.766S24.5,6.215,24.5,12.7H24.593z"/>
+		<path fill="#3A62CA" d="M24.564,12.7c0,6.469-5.27,11.737-11.737,11.737C6.266,24.527,0.999,19.261,0.999,12.7
+			c0-6.561,5.267-11.737,11.736-11.737c6.469,0,11.738,5.268,11.738,11.736L24.564,12.7L24.564,12.7z"/>
+		<path fill="#3B62CB" d="M24.536,12.7c0,6.452-5.255,11.707-11.708,11.707C6.284,24.5,1.029,19.245,1.029,12.7
+			c0-6.545,5.255-11.707,11.707-11.707s11.708,5.255,11.708,11.708L24.536,12.7L24.536,12.7z"/>
+		<path fill="#3C62CC" d="M24.508,12.701c0,6.438-5.24,11.678-11.678,11.678c-6.529,0.092-11.77-5.15-11.77-11.678
+			c0-6.528,5.241-11.679,11.678-11.679S24.416,6.263,24.416,12.7L24.508,12.701L24.508,12.701z"/>
+		<path fill="#3C62CD" d="M24.479,12.7c0,6.421-5.229,11.649-11.648,11.649C6.318,24.439,1.09,19.212,1.09,12.7
+			c0-6.513,5.228-11.649,11.649-11.649c6.42,0,11.65,5.228,11.65,11.649H24.479z"/>
+		<path fill="#3D63CE" d="M24.45,12.7c0,6.403-5.216,11.618-11.62,11.618C6.335,24.41,1.12,19.195,1.12,12.7
+			c0-6.497,5.215-11.62,11.62-11.62c6.404,0,11.619,5.215,11.619,11.62H24.45z"/>
+		<path fill="#3E63CF" d="M24.423,12.7c0,6.389-5.202,11.591-11.591,11.591C6.353,24.382,1.15,19.18,1.15,12.7
+			c0-6.48,5.203-11.591,11.591-11.591c6.388,0,11.59,5.203,11.59,11.591H24.423z"/>
+		<path fill="#3F63D0" d="M24.395,12.701c0,6.373-5.188,11.561-11.562,11.561C6.37,24.354,1.18,19.164,1.18,12.701
+			c0-6.464,5.189-11.562,11.562-11.562c6.371,0,11.562,5.189,11.562,11.562H24.395z"/>
+		<path fill="#4063D1" d="M24.365,12.7c0,6.356-5.176,11.532-11.532,11.532C6.387,24.322,1.21,19.146,1.21,12.7
+			c0-6.447,5.177-11.533,11.533-11.533c6.354,0,11.532,5.176,11.532,11.533H24.365z"/>
+		<path fill="#4063D2" d="M24.337,12.7c0,6.341-5.163,11.503-11.503,11.503C6.403,24.293,1.24,19.13,1.24,12.7
+			c0-6.431,5.163-11.503,11.503-11.503c6.34,0,11.504,5.163,11.504,11.503H24.337z"/>
+		<path fill="#4163D3" d="M24.311,12.7c0,6.323-5.15,11.474-11.476,11.474C6.42,24.264,1.271,19.114,1.271,12.7
+			c0-6.415,5.149-11.474,11.474-11.474c6.323,0,11.474,5.15,11.474,11.474H24.311z"/>
+		<path fill="#4263D4" d="M24.281,12.701c0,6.308-5.137,11.445-11.445,11.445C6.438,24.234,1.301,19.1,1.301,12.701
+			c0-6.399,5.137-11.445,11.445-11.445c6.307,0,11.445,5.136,11.445,11.445H24.281z"/>
+		<path fill="#4363D4" d="M24.253,12.7c0,6.292-5.124,11.416-11.416,11.416C6.455,24.205,1.332,19.082,1.332,12.7
+			c0-6.382,5.123-11.415,11.415-11.415S24.163,6.408,24.163,12.7H24.253z"/>
+		<path fill="#4463D5" d="M24.225,12.7c0,6.276-5.111,11.387-11.387,11.387C6.472,24.176,1.362,19.064,1.362,12.7
+			c0-6.366,5.11-11.386,11.386-11.386c6.275,0,11.387,5.11,11.387,11.386H24.225z"/>
+		<path fill="#4563D6" d="M24.195,12.7c0,6.26-5.098,11.356-11.357,11.356C6.49,24.146,1.392,19.049,1.392,12.7
+			c0-6.35,5.098-11.357,11.357-11.357S24.105,6.441,24.105,12.7H24.195z"/>
+		<path fill="#4563D7" d="M24.167,12.7c0,6.243-5.084,11.327-11.328,11.327C6.506,24.116,1.422,19.033,1.422,12.7
+			S6.506,1.372,12.75,1.372S24.078,6.456,24.078,12.7H24.167z"/>
+		<path fill="#4663D8" d="M24.139,12.7c0,6.228-5.07,11.299-11.299,11.299C6.523,24.087,1.453,19.018,1.453,12.7
+			S6.523,1.401,12.751,1.401c6.228,0,11.298,5.071,11.298,11.299H24.139z"/>
+		<path fill="#4763D9" d="M24.109,12.7c0,6.212-5.058,11.271-11.27,11.271C6.541,24.059,1.483,19,1.483,12.7
+			c0-6.3,5.058-11.27,11.27-11.27S24.023,6.488,24.023,12.7H24.109z"/>
+		<path fill="#4863DA" d="M24.082,12.7c0,6.194-5.045,11.239-11.24,11.239C6.558,24.027,1.513,18.982,1.513,12.7
+			c0-6.284,5.045-11.24,11.24-11.24c6.195,0,11.241,5.045,11.241,11.24H24.082z"/>
+		<path fill="#4964DB" d="M24.055,12.7c0,6.18-5.033,11.211-11.212,11.211c-6.268,0.088-11.3-4.943-11.3-11.211
+			c0-6.268,5.032-11.211,11.211-11.211c6.18,0,11.212,5.032,11.212,11.211H24.055z"/>
+		<path fill="#4964DC" d="M24.025,12.7c0,6.164-5.02,11.182-11.183,11.182C6.592,23.971,1.574,18.951,1.574,12.7
+			S6.593,1.518,12.756,1.518S23.938,6.537,23.938,12.7H24.025z"/>
+		<path fill="#4A64DD" d="M23.997,12.7c0,6.147-5.006,11.153-11.153,11.153C6.609,23.939,1.604,18.936,1.604,12.7
+			S6.609,1.547,12.757,1.547c6.146,0,11.152,5.006,11.152,11.153H23.997z"/>
+		<path fill="#4B64DE" d="M23.969,12.7c0,6.131-4.992,11.124-11.124,11.124C6.626,23.91,1.634,18.918,1.634,12.7
+			c0-6.219,4.992-11.124,11.124-11.124c6.131,0,11.124,4.992,11.124,11.124H23.969z"/>
+		<path fill="#4C64DF" d="M23.939,12.7c0,6.114-4.979,11.095-11.094,11.095C6.644,23.882,1.665,18.902,1.665,12.7
+			c0-6.203,4.979-11.094,11.094-11.094c6.115,0,11.095,4.979,11.095,11.094H23.939z"/>
+		<path fill="#4D64E0" d="M23.912,12.7c0,6.1-4.967,11.065-11.065,11.065C6.661,23.852,1.695,18.886,1.695,12.7
+			c0-6.186,4.966-11.065,11.065-11.065c6.098,0,11.065,4.966,11.065,11.065H23.912z"/>
+		<path fill="#4E64E1" d="M23.884,12.7c0,6.083-4.952,11.036-11.036,11.036C6.678,23.822,1.725,18.869,1.725,12.7
+			c0-6.17,4.954-11.036,11.036-11.036c6.083,0,11.036,4.954,11.036,11.036H23.884z"/>
+		<path fill="#4E64E2" d="M23.855,12.7c0,6.067-4.94,11.007-11.007,11.007C6.695,23.793,1.755,18.854,1.755,12.7
+			c0-6.154,4.94-11.007,11.007-11.007c6.066,0,11.005,4.94,11.005,11.007H23.855z"/>
+		<path fill="#4F64E3" d="M23.827,12.7c0,6.051-4.929,10.978-10.978,10.978C6.712,23.764,1.786,18.837,1.786,12.7
+			c0-6.137,4.927-10.978,10.978-10.978c6.05,0,10.977,4.927,10.977,10.978H23.827z"/>
+		<path fill="#5064E4" d="M23.799,12.7c0,6.034-4.914,10.948-10.949,10.948C6.729,23.734,1.816,18.82,1.816,12.7
+			c0-6.121,4.914-10.948,10.948-10.948c6.034,0,10.949,4.914,10.949,10.948H23.799z"/>
+		<path fill="#5164E5" d="M23.771,12.7c0,6.019-4.901,10.919-10.919,10.919C6.747,23.705,1.846,18.805,1.846,12.7
+			c0-6.105,4.9-10.919,10.919-10.919c6.018,0,10.918,4.9,10.918,10.919H23.771z"/>
+		<path fill="#5264E6" d="M23.742,12.7c0,6.003-4.889,10.89-10.891,10.89C6.764,23.675,1.876,18.788,1.876,12.7
+			c0-6.088,4.888-10.89,10.89-10.89c6.001,0,10.89,4.888,10.89,10.89H23.742z"/>
+		<path fill="#5264E7" d="M23.714,12.7c0,5.985-4.875,10.86-10.861,10.86C6.781,23.646,1.906,18.771,1.906,12.7
+			c0-6.072,4.875-10.861,10.861-10.861c5.985,0,10.86,4.875,10.86,10.861H23.714z"/>
+		<path fill="#5364E8" d="M23.686,12.7c0,5.971-4.861,10.832-10.832,10.832C6.798,23.616,1.937,18.755,1.937,12.7
+			c0-6.056,4.862-10.832,10.832-10.832C18.738,1.869,23.6,6.73,23.6,12.7H23.686z"/>
+		<path fill="#5464E9" d="M23.657,12.7c0,5.954-4.849,10.803-10.803,10.803C6.815,23.587,1.967,18.739,1.967,12.7
+			c0-6.04,4.849-10.802,10.803-10.802c5.955,0,10.802,4.848,10.802,10.802H23.657z"/>
+		<path fill="#5565EA" d="M23.629,12.7c0,5.938-4.836,10.772-10.774,10.772C6.833,23.559,1.998,18.723,1.998,12.7
+			c0-6.023,4.835-10.773,10.773-10.773S23.544,6.762,23.544,12.7H23.629z"/>
+		<path fill="#5665EB" d="M23.602,12.7c0,5.922-4.824,10.743-10.746,10.743C6.85,23.527,2.027,18.706,2.027,12.7
+			c0-6.006,4.822-10.744,10.744-10.744c5.922,0,10.745,4.822,10.745,10.744H23.602z"/>
+		<path fill="#5665EC" d="M23.572,12.7c0,5.905-4.811,10.715-10.715,10.715C6.867,23.499,2.058,18.689,2.058,12.7
+			c0-5.99,4.809-10.715,10.714-10.715S23.486,6.794,23.486,12.7H23.572z"/>
+		<path fill="#5765ED" d="M23.544,12.7c0,5.89-4.797,10.686-10.687,10.686C6.884,23.471,2.088,18.674,2.088,12.7
+			c0-5.974,4.796-10.686,10.686-10.686c5.889,0,10.686,4.796,10.686,10.686H23.544z"/>
+		<path fill="#5865EE" d="M23.516,12.7c0,5.874-4.783,10.655-10.657,10.655C6.901,23.439,2.118,18.657,2.118,12.7
+			c0-5.958,4.783-10.657,10.657-10.657c5.874,0,10.657,4.784,10.657,10.657H23.516z"/>
+		<path fill="#5965EF" d="M23.486,12.7c0,5.858-4.771,10.627-10.627,10.627C6.918,23.41,2.148,18.641,2.148,12.7
+			c0-5.941,4.77-10.627,10.627-10.627S23.402,6.843,23.402,12.7H23.486z"/>
+		<path fill="#5A65F0" d="M23.459,12.7c0,5.842-4.758,10.598-10.599,10.598C6.936,23.381,2.179,18.625,2.179,12.7
+			c0-5.925,4.757-10.598,10.598-10.598c5.841,0,10.598,4.757,10.598,10.598H23.459z"/>
+		<path fill="#5B65F1" d="M23.432,12.7c0,5.825-4.744,10.569-10.571,10.569C6.953,23.352,2.209,18.607,2.209,12.7
+			c0-5.909,4.744-10.569,10.569-10.569c5.826,0,10.57,4.744,10.57,10.569H23.432z"/>
+		<path fill="#5B65F2" d="M23.4,12.7c0,5.81-4.729,10.54-10.54,10.54C6.97,23.322,2.239,18.592,2.239,12.7
+			c0-5.892,4.73-10.54,10.54-10.54c5.809,0,10.54,4.73,10.54,10.54H23.4z"/>
+		<path fill="#5C65F3" d="M23.373,12.7c0,5.794-4.719,10.511-10.511,10.511C6.987,23.293,2.27,18.576,2.27,12.7
+			S6.987,2.189,12.78,2.189c5.793,0,10.511,4.717,10.511,10.511H23.373z"/>
+		<path fill="#5D65F4" d="M23.346,12.7c0,5.776-4.705,10.481-10.482,10.481C7.004,23.264,2.3,18.561,2.3,12.7
+			S7.004,2.219,12.781,2.219c5.775,0,10.48,4.704,10.48,10.481H23.346z"/>
+		<path fill="#5E65F5" d="M23.316,12.7c0,5.762-4.691,10.452-10.453,10.452C7.021,23.232,2.33,18.543,2.33,12.7
+			c0-5.843,4.691-10.452,10.452-10.452c5.761,0,10.452,4.691,10.452,10.452H23.316z"/>
+		<path fill="#5F65F6" d="M23.288,12.7c0,5.745-4.679,10.423-10.423,10.423C7.039,23.204,2.36,18.525,2.36,12.7
+			c0-5.827,4.678-10.423,10.423-10.423c5.744,0,10.423,4.678,10.423,10.423H23.288z"/>
+		<path fill="#5F65F7" d="M23.26,12.7c0,5.729-4.664,10.394-10.394,10.394C7.056,23.175,2.391,18.511,2.391,12.7
+			c0-5.811,4.665-10.393,10.394-10.393c5.729,0,10.393,4.665,10.393,10.394L23.26,12.7L23.26,12.7z"/>
+		<path fill="#6066F8" d="M23.23,12.7c0,5.713-4.651,10.364-10.364,10.364C7.073,23.146,2.421,18.494,2.421,12.7
+			S7.073,2.335,12.786,2.335c5.712,0,10.364,4.652,10.364,10.365H23.23z"/>
+		<path fill="#6166F9" d="M23.203,12.7c0,5.696-4.639,10.335-10.335,10.335C7.09,23.116,2.451,18.479,2.451,12.7
+			S7.09,2.365,12.786,2.365S23.121,7.004,23.121,12.7H23.203z"/>
+		<path fill="#6266FA" d="M23.175,12.7c0,5.681-4.626,10.306-10.307,10.306C7.107,23.087,2.481,18.462,2.481,12.7
+			c0-5.762,4.626-10.306,10.307-10.306c5.68,0,10.306,4.625,10.306,10.306H23.175z"/>
+		<path fill="#6366FB" d="M23.146,12.7c0,5.665-4.613,10.276-10.277,10.276C7.124,23.059,2.512,18.445,2.512,12.7
+			c0-5.746,4.612-10.277,10.277-10.277S23.064,7.036,23.064,12.7H23.146z"/>
+		<path fill="#6466FC" d="M23.118,12.7c0,5.647-4.601,10.248-10.248,10.248C7.142,23.027,2.542,18.43,2.542,12.7
+			c0-5.729,4.6-10.248,10.248-10.248c5.647,0,10.247,4.6,10.247,10.248H23.118z"/>
+		<path fill="#6466FD" d="M23.09,12.7c0,5.633-4.587,10.219-10.219,10.219C7.159,22.998,2.572,18.412,2.572,12.7
+			c0-5.713,4.586-10.219,10.219-10.219c5.632,0,10.219,4.586,10.219,10.219H23.09z"/>
+		<path fill="#6566FE" d="M23.062,12.7c0,5.616-4.574,10.188-10.19,10.188C7.176,22.969,2.603,18.396,2.603,12.7
+			S7.176,2.511,12.792,2.511c5.615,0,10.188,4.573,10.188,10.189H23.062z"/>
+		<path fill="#6666FF" d="M23.033,12.7c0,5.601-4.561,10.159-10.161,10.159c-5.68,0.08-10.24-4.479-10.24-10.159
+			c0-5.68,4.56-10.16,10.16-10.16c5.601,0,10.16,4.56,10.16,10.16H23.033z"/>
+	</g>
+	
+		<linearGradient id="XMLID_12_" gradientUnits="userSpaceOnUse" x1="198.625" y1="-253.916" x2="198.625" y2="-262.334" gradientTransform="matrix(1 0 0 -1 -186 -252.5)">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="1" style="stop-color:#6666FF"/>
+	</linearGradient>
+	<ellipse fill="url(#XMLID_12_)" cx="12.625" cy="5.625" rx="7.542" ry="4.209"/>
+	<g>
+		<path fill="#FFFFFF" d="M14.1,19.2c0,0.2,0,0.3-0.3,0.3H12c-0.2,0-0.3-0.1-0.3-0.3v-7.1h-1.4c-0.2,0-0.3-0.1-0.3-0.3v-1.2
+			c0-0.2,0-0.3,0.3-0.3h3.5c0.2,0,0.3,0.1,0.3,0.3v8.5V19.2z M13,9.2c-0.8,0-1.5-0.7-1.5-1.5c0-0.8,0.7-1.5,1.5-1.5s1.5,0.7,1.5,1.5
+			C14.5,8.5,13.8,9.2,13,9.2z"/>
+	</g>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/prev.svg b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/prev.svg
new file mode 100644
index 0000000..7ceddec
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/prev.svg
@@ -0,0 +1,338 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.1" id="Previous" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="48" height="48" viewBox="0 0 48 48"
+	 overflow="visible" enable-background="new 0 0 48 48" xml:space="preserve">
+<g>
+	<path fill="#FFFFFF" stroke="#FFFFFF" stroke-width="7.5901" stroke-linejoin="round" d="M25.659,6.898c0-0.301-0.3-0.301-0.5-0.2
+		l-16.6,16.9c-0.5,0.5-0.4,0.7,0,1l16.6,16.7c0.103,0.101,0.399,0.101,0.399-0.1v-10h13.601c0.301,0,0.5-0.2,0.5-0.4v-13.3
+		c0-0.4-0.199-0.5-0.601-0.5h-13.5L25.659,6.898z"/>
+	<g>
+		<path fill="#0033CC" d="M25.659,6.898c0-0.301-0.3-0.301-0.5-0.2l-16.6,16.9c-0.5,0.5-0.4,0.7,0,1l16.6,16.7
+			c0.103,0.101,0.399,0.101,0.399-0.1v-10h13.601c0.301,0,0.5-0.2,0.5-0.4v-13.3c0-0.4-0.199-0.5-0.601-0.5h-13.5L25.659,6.898z"/>
+		<path fill="#0134CC" d="M25.648,6.925c0-0.3-0.299-0.3-0.498-0.2L8.575,23.6c-0.499,0.499-0.4,0.698,0,1L25.15,41.271
+			c0.101,0.102,0.398,0.102,0.398-0.1v-9.984h13.58c0.303,0,0.5-0.197,0.5-0.397V17.508c0-0.4-0.197-0.499-0.6-0.499H25.55
+			L25.648,6.925z"/>
+		<path fill="#0235CD" d="M25.641,6.953c0-0.3-0.3-0.3-0.498-0.2L8.588,23.601c-0.499,0.498-0.399,0.697,0,0.997l16.553,16.647
+			c0.101,0.101,0.398,0.101,0.398-0.101v-9.971h13.562c0.299,0,0.498-0.197,0.498-0.398V17.519c0-0.399-0.199-0.499-0.6-0.499H25.54
+			L25.641,6.953z"/>
+		<path fill="#0336CD" d="M25.63,6.979c0-0.299-0.299-0.299-0.498-0.199L8.603,23.601c-0.498,0.498-0.399,0.696,0,0.997
+			l16.529,16.62c0.101,0.101,0.397,0.101,0.397-0.099v-9.954h13.544c0.299,0,0.495-0.199,0.495-0.397v-13.24
+			c0-0.399-0.196-0.498-0.598-0.498H25.532L25.63,6.979z"/>
+		<path fill="#0437CE" d="M25.622,7.005c0-0.299-0.299-0.299-0.498-0.199L8.619,23.602c-0.498,0.497-0.398,0.695,0,0.994
+			l16.505,16.598c0.101,0.1,0.396,0.1,0.396-0.102v-9.938h13.521c0.301,0,0.498-0.197,0.498-0.396V17.54
+			c0-0.397-0.197-0.497-0.598-0.497h-13.42L25.622,7.005z"/>
+		<path fill="#0538CE" d="M25.611,7.033c0-0.298-0.299-0.298-0.498-0.199L8.633,23.602c-0.497,0.496-0.398,0.694,0,0.994
+			l16.48,16.568c0.101,0.1,0.398,0.1,0.398-0.1v-9.924h13.502c0.299,0,0.498-0.197,0.498-0.396V17.548
+			c0-0.397-0.199-0.496-0.598-0.496h-13.4L25.611,7.033z"/>
+		<path fill="#0639CF" d="M25.602,7.06c0-0.298-0.297-0.298-0.496-0.199L8.646,23.603c-0.496,0.496-0.396,0.693,0,0.99
+			l16.458,16.546c0.101,0.101,0.396,0.101,0.396-0.1v-9.907h13.482c0.301,0,0.496-0.196,0.496-0.396V17.56
+			c0-0.396-0.195-0.495-0.595-0.495H25.503L25.602,7.06z"/>
+		<path fill="#073ACF" d="M25.592,7.085c0-0.298-0.298-0.298-0.494-0.199L8.662,23.603c-0.495,0.495-0.396,0.692,0,0.989
+			l16.436,16.518c0.1,0.102,0.396,0.102,0.396-0.098V31.12h13.465c0.297,0,0.494-0.197,0.494-0.396V17.569
+			c0-0.396-0.197-0.495-0.595-0.495H25.493L25.592,7.085z"/>
+		<path fill="#083BD0" d="M25.583,7.111c0-0.297-0.297-0.297-0.494-0.198L8.677,23.604c-0.494,0.494-0.396,0.691,0,0.987
+			l16.412,16.493c0.101,0.1,0.396,0.1,0.396-0.1v-9.877h13.447c0.297,0,0.493-0.195,0.493-0.396V17.58
+			c0-0.396-0.196-0.494-0.594-0.494H25.484L25.583,7.111z"/>
+		<path fill="#093CD0" d="M25.573,7.139c0-0.296-0.296-0.296-0.494-0.197L8.69,23.604c-0.493,0.494-0.395,0.69,0,0.985l16.389,16.47
+			c0.103,0.099,0.396,0.099,0.396-0.101V31.1h13.428c0.298,0,0.494-0.197,0.494-0.396V17.589c0-0.395-0.196-0.493-0.594-0.493
+			H25.475L25.573,7.139z"/>
+		<path fill="#0A3DD1" d="M25.562,7.165c0-0.296-0.295-0.296-0.492-0.197L8.706,23.604c-0.493,0.492-0.395,0.688,0,0.983
+			l16.366,16.44c0.1,0.098,0.396,0.098,0.396-0.101v-9.845h13.405c0.297,0,0.494-0.196,0.494-0.396V17.596
+			c0-0.395-0.197-0.492-0.592-0.492H25.464L25.562,7.165z"/>
+		<path fill="#0B3ED1" d="M25.555,7.191c0-0.295-0.296-0.295-0.492-0.197L8.72,23.605c-0.492,0.491-0.394,0.688,0,0.982
+			l16.342,16.414c0.1,0.099,0.395,0.099,0.395-0.099v-9.828h13.391c0.295,0,0.49-0.197,0.49-0.395V17.609
+			c0-0.393-0.195-0.491-0.59-0.491H25.456L25.555,7.191z"/>
+		<path fill="#0C3FD2" d="M25.544,7.219c0-0.295-0.295-0.295-0.491-0.196L8.734,23.606c-0.491,0.49-0.394,0.687,0,0.98
+			l16.318,16.389c0.099,0.101,0.394,0.101,0.394-0.098v-9.812h13.369c0.297,0,0.492-0.194,0.492-0.394V17.62
+			c0-0.393-0.195-0.49-0.591-0.49H25.445L25.544,7.219z"/>
+		<path fill="#0D40D2" d="M25.534,7.245c0-0.294-0.293-0.294-0.49-0.196L8.749,23.606c-0.491,0.489-0.394,0.685,0,0.979
+			l16.295,16.362c0.099,0.098,0.394,0.098,0.394-0.098v-9.798h13.35c0.295,0,0.49-0.196,0.49-0.395V17.628
+			c0-0.392-0.195-0.489-0.588-0.489H25.438L25.534,7.245z"/>
+		<path fill="#0E41D3" d="M25.525,7.271c0-0.294-0.295-0.294-0.489-0.196L8.764,23.607c-0.49,0.489-0.393,0.685,0,0.979
+			l16.271,16.335c0.102,0.101,0.395,0.101,0.395-0.097v-9.782h13.33c0.295,0,0.488-0.194,0.488-0.394V17.64
+			c0-0.392-0.193-0.489-0.588-0.489H25.428L25.525,7.271z"/>
+		<path fill="#0F42D3" d="M25.516,7.298c0-0.293-0.293-0.293-0.488-0.195L8.778,23.607c-0.489,0.489-0.392,0.684,0,0.978
+			l16.248,16.312c0.101,0.099,0.394,0.099,0.394-0.099v-9.767H38.73c0.293,0,0.49-0.195,0.49-0.393V17.65
+			c0-0.391-0.197-0.488-0.589-0.488H25.417L25.516,7.298z"/>
+		<path fill="#1043D4" d="M25.505,7.325c0-0.293-0.293-0.293-0.487-0.195L8.792,23.608c-0.488,0.488-0.391,0.683,0,0.976
+			l16.224,16.283c0.101,0.098,0.394,0.098,0.394-0.098v-9.752H38.7c0.295,0,0.489-0.192,0.489-0.39V17.661
+			c0-0.391-0.194-0.487-0.586-0.487H25.409L25.505,7.325z"/>
+		<path fill="#1144D4" d="M25.497,7.352c0-0.292-0.293-0.292-0.487-0.194L8.808,23.608c-0.488,0.487-0.391,0.682,0,0.974
+			L25.009,40.84c0.099,0.1,0.392,0.1,0.392-0.097v-9.734h13.272c0.293,0,0.488-0.194,0.488-0.39V17.67
+			c0-0.39-0.195-0.487-0.586-0.487H25.398L25.497,7.352z"/>
+		<path fill="#1245D5" d="M25.486,7.378c0-0.292-0.293-0.292-0.487-0.195L8.822,23.609c-0.487,0.486-0.39,0.68,0,0.973l16.177,16.23
+			c0.099,0.099,0.392,0.099,0.392-0.099v-9.72h13.254c0.293,0,0.485-0.194,0.485-0.391V17.681c0-0.389-0.192-0.486-0.584-0.486
+			H25.391L25.486,7.378z"/>
+		<path fill="#1346D5" d="M25.479,7.406c0-0.292-0.293-0.292-0.486-0.195L8.837,23.61c-0.487,0.485-0.39,0.679,0,0.971
+			l16.154,16.206c0.098,0.097,0.389,0.097,0.389-0.098v-9.705h13.236c0.291,0,0.485-0.192,0.485-0.389V17.69
+			c0-0.388-0.194-0.485-0.584-0.485H25.38L25.479,7.406z"/>
+		<path fill="#1447D6" d="M25.468,7.432c0-0.292-0.292-0.292-0.485-0.194L8.852,23.611c-0.485,0.484-0.389,0.678,0,0.969
+			l16.13,16.18c0.1,0.098,0.389,0.098,0.389-0.096v-9.688h13.217c0.291,0,0.486-0.192,0.486-0.39V17.702
+			c0-0.388-0.195-0.484-0.584-0.484H25.37L25.468,7.432z"/>
+		<path fill="#1548D6" d="M25.458,7.458c0-0.291-0.291-0.291-0.485-0.194L8.866,23.611c-0.484,0.483-0.388,0.677,0,0.968
+			L24.973,40.73c0.1,0.099,0.389,0.099,0.389-0.097v-9.673h13.197c0.291,0,0.483-0.193,0.483-0.388V17.71
+			c0-0.387-0.192-0.483-0.582-0.483H25.359L25.458,7.458z"/>
+		<path fill="#1649D7" d="M25.448,7.484c0-0.291-0.289-0.291-0.484-0.194L8.88,23.613c-0.484,0.482-0.388,0.675,0,0.965
+			l16.083,16.128c0.098,0.099,0.389,0.099,0.389-0.097v-9.657h13.178c0.291,0,0.484-0.192,0.484-0.388V17.722
+			c0-0.387-0.193-0.482-0.582-0.482h-13.08L25.448,7.484z"/>
+		<path fill="#174AD7" d="M25.439,7.512c0-0.29-0.291-0.29-0.483-0.193L8.895,23.614c-0.483,0.482-0.387,0.675,0,0.963l16.06,16.104
+			c0.1,0.096,0.391,0.096,0.391-0.098v-9.645H38.5c0.291,0,0.484-0.191,0.484-0.385V17.731c0-0.386-0.193-0.481-0.58-0.481H25.343
+			L25.439,7.512z"/>
+		<path fill="#184BD8" d="M25.43,7.539c0-0.29-0.289-0.29-0.482-0.193L8.91,23.614c-0.482,0.482-0.387,0.674,0,0.962L24.947,40.65
+			c0.098,0.098,0.387,0.098,0.387-0.096V30.93h13.141c0.291,0,0.48-0.193,0.48-0.388v-12.8c0-0.385-0.189-0.481-0.578-0.481H25.333
+			L25.43,7.539z"/>
+		<path fill="#194CD8" d="M25.419,7.564c0-0.289-0.289-0.289-0.481-0.192L8.923,23.614c-0.481,0.481-0.386,0.673,0,0.961
+			l16.015,16.05c0.097,0.098,0.386,0.098,0.386-0.098v-9.608h13.118c0.291,0,0.482-0.19,0.482-0.386V17.751
+			c0-0.385-0.191-0.48-0.578-0.48H25.323L25.419,7.564z"/>
+		<path fill="#1A4DD9" d="M25.411,7.59c0-0.288-0.289-0.288-0.479-0.192L8.938,23.615c-0.481,0.48-0.385,0.671,0,0.96L24.93,40.598
+			c0.096,0.096,0.385,0.096,0.385-0.096v-9.595h13.102c0.289,0,0.48-0.192,0.48-0.386V17.762c0-0.384-0.191-0.479-0.578-0.479
+			H25.314L25.411,7.59z"/>
+		<path fill="#1B4ED9" d="M25.4,7.618c0-0.288-0.289-0.288-0.479-0.191L8.954,23.616c-0.481,0.479-0.385,0.67,0,0.958L24.919,40.57
+			c0.099,0.097,0.386,0.097,0.386-0.096v-9.58h13.082c0.288,0,0.479-0.189,0.479-0.383V17.771c0-0.383-0.191-0.479-0.576-0.479
+			H25.305L25.4,7.618z"/>
+		<path fill="#1C4FDA" d="M25.393,7.645c0-0.287-0.289-0.287-0.48-0.191L8.968,23.617c-0.48,0.479-0.384,0.669,0,0.958
+			l15.941,15.971c0.099,0.097,0.385,0.097,0.385-0.095v-9.562h13.062c0.289,0,0.48-0.193,0.48-0.384V17.782
+			c0-0.383-0.191-0.478-0.577-0.478H25.294L25.393,7.645z"/>
+		<path fill="#1D50DA" d="M25.38,7.67c0-0.287-0.286-0.287-0.479-0.19L8.981,23.617c-0.479,0.478-0.384,0.667,0,0.955L24.9,40.518
+			c0.097,0.096,0.384,0.096,0.384-0.098v-9.548h13.043c0.289,0,0.479-0.188,0.479-0.383V17.792c0-0.382-0.19-0.477-0.576-0.477
+			H25.286L25.38,7.67z"/>
+		<path fill="#1E51DB" d="M25.372,7.698c0-0.287-0.287-0.287-0.479-0.191L8.997,23.618c-0.479,0.477-0.383,0.667,0,0.954
+			L24.893,40.49c0.098,0.095,0.385,0.095,0.385-0.096v-9.533H38.3c0.287,0,0.479-0.189,0.479-0.381V17.803
+			c0-0.382-0.191-0.476-0.574-0.476h-12.93L25.372,7.698z"/>
+		<path fill="#1F52DB" d="M25.361,7.725c0-0.286-0.284-0.286-0.479-0.19L9.012,23.619c-0.478,0.475-0.383,0.666,0,0.951
+			l15.872,15.895c0.097,0.096,0.384,0.096,0.384-0.095v-9.519h13.004c0.287,0,0.479-0.189,0.479-0.381V17.812
+			c0-0.381-0.19-0.476-0.574-0.476H25.268L25.361,7.725z"/>
+		<path fill="#2053DC" d="M25.354,7.75c0-0.286-0.287-0.286-0.479-0.19L9.025,23.619c-0.477,0.475-0.382,0.665,0,0.951
+			l15.849,15.867c0.099,0.095,0.385,0.095,0.385-0.098v-9.501h12.982c0.286,0,0.479-0.188,0.479-0.381V17.823
+			c0-0.38-0.188-0.475-0.574-0.475h-12.89L25.354,7.75z"/>
+		<path fill="#2154DC" d="M25.343,7.777c0-0.286-0.286-0.286-0.477-0.19L9.04,23.619c-0.476,0.475-0.381,0.664,0,0.949L24.867,40.41
+			c0.096,0.095,0.383,0.095,0.383-0.094V30.83h12.965c0.287,0,0.479-0.189,0.479-0.38V17.832c0-0.379-0.188-0.474-0.569-0.474
+			H25.249L25.343,7.777z"/>
+		<path fill="#2255DD" d="M25.333,7.805c0-0.285-0.285-0.285-0.478-0.19L9.056,23.62c-0.476,0.474-0.381,0.663,0,0.948
+			l15.801,15.812c0.098,0.096,0.383,0.096,0.383-0.095v-9.472h12.945c0.285,0,0.477-0.188,0.477-0.381V17.842
+			c0-0.378-0.188-0.473-0.569-0.473H25.238L25.333,7.805z"/>
+		<path fill="#2356DD" d="M25.325,7.832c0-0.284-0.285-0.284-0.478-0.189L9.069,23.621c-0.475,0.473-0.381,0.662,0,0.945
+			l15.779,15.791c0.096,0.094,0.381,0.094,0.381-0.098v-9.451h12.929c0.284,0,0.477-0.189,0.477-0.379V17.853
+			c0-0.378-0.188-0.472-0.569-0.472H25.229L25.325,7.832z"/>
+		<path fill="#2457DE" d="M25.314,7.857c0-0.284-0.285-0.284-0.477-0.189L9.084,23.622c-0.474,0.472-0.38,0.66,0,0.944L24.838,40.33
+			c0.098,0.094,0.381,0.094,0.381-0.094v-9.439h12.908c0.285,0,0.475-0.189,0.475-0.378V17.863c0-0.378-0.188-0.471-0.567-0.471
+			H25.221L25.314,7.857z"/>
+		<path fill="#2558DE" d="M25.305,7.883c0-0.283-0.283-0.283-0.474-0.188L9.099,23.622c-0.473,0.471-0.379,0.659,0,0.942
+			L24.831,40.3c0.095,0.097,0.379,0.097,0.379-0.094v-9.424H38.1c0.284,0,0.475-0.188,0.475-0.38V17.873
+			c0-0.377-0.188-0.47-0.568-0.47H25.21L25.305,7.883z"/>
+		<path fill="#2659DF" d="M25.294,7.911c0-0.283-0.282-0.283-0.474-0.188l-15.708,15.9c-0.473,0.47-0.378,0.658,0,0.941
+			L24.82,40.275c0.097,0.094,0.38,0.094,0.38-0.094v-9.408h12.868c0.285,0,0.476-0.188,0.476-0.377V17.882
+			c0-0.376-0.188-0.469-0.567-0.469H25.2L25.294,7.911z"/>
+		<path fill="#275ADF" d="M25.286,7.938c0-0.282-0.283-0.282-0.474-0.188L9.127,23.624c-0.472,0.469-0.378,0.657,0,0.938
+			L24.812,40.25c0.097,0.094,0.379,0.094,0.379-0.093v-9.394h12.851c0.283,0,0.476-0.188,0.476-0.379V17.894
+			c0-0.375-0.188-0.469-0.566-0.469h-12.76L25.286,7.938z"/>
+		<path fill="#285BE0" d="M25.275,7.963c0-0.282-0.282-0.282-0.473-0.188L9.143,23.624c-0.471,0.469-0.377,0.656,0,0.938
+			l15.662,15.658c0.096,0.094,0.379,0.094,0.379-0.094V30.75h12.83c0.282,0,0.473-0.188,0.473-0.376V17.902
+			c0-0.375-0.188-0.468-0.564-0.468h-12.74L25.275,7.963z"/>
+		<path fill="#295CE0" d="M25.268,7.991c0-0.281-0.283-0.281-0.474-0.188L9.158,23.624c-0.471,0.468-0.377,0.655,0,0.937
+			l15.638,15.633c0.095,0.096,0.377,0.096,0.377-0.092V30.74h12.812c0.283,0,0.473-0.188,0.473-0.375V17.914
+			c0-0.375-0.188-0.467-0.564-0.467H25.171L25.268,7.991z"/>
+		<path fill="#2A5DE1" d="M25.257,8.018c0-0.281-0.282-0.281-0.471-0.188L9.171,23.625c-0.47,0.467-0.377,0.654,0,0.936
+			l15.615,15.605c0.094,0.093,0.377,0.093,0.377-0.093v-9.347h12.793c0.28,0,0.471-0.188,0.471-0.375V17.923
+			c0-0.374-0.188-0.467-0.563-0.467h-12.7L25.257,8.018z"/>
+		<path fill="#2B5EE1" d="M25.247,8.043c0-0.28-0.28-0.28-0.472-0.187L9.187,23.625c-0.469,0.467-0.376,0.653,0,0.934l15.59,15.582
+			c0.096,0.092,0.377,0.092,0.377-0.094v-9.33h12.773c0.28,0,0.471-0.188,0.471-0.373v-12.41c0-0.373-0.188-0.466-0.562-0.466
+			H25.152L25.247,8.043z"/>
+		<path fill="#2C5FE2" d="M25.238,8.07c0-0.28-0.282-0.28-0.471-0.186L9.201,23.625c-0.468,0.466-0.375,0.652,0,0.932L24.77,40.114
+			c0.096,0.093,0.375,0.093,0.375-0.095v-9.312h12.754c0.281,0,0.471-0.188,0.471-0.373V17.943c0-0.373-0.188-0.465-0.562-0.465
+			H25.145L25.238,8.07z"/>
+		<path fill="#2D60E2" d="M25.229,8.097c0-0.28-0.279-0.28-0.469-0.187L9.214,23.626c-0.468,0.465-0.375,0.651,0,0.931L24.76,40.086
+			c0.094,0.094,0.374,0.094,0.374-0.093v-9.3H37.87c0.278,0,0.469-0.188,0.469-0.371V17.954c0-0.372-0.188-0.464-0.562-0.464H25.134
+			L25.229,8.097z"/>
+		<path fill="#2E61E3" d="M25.219,8.124c0-0.279-0.281-0.279-0.468-0.186L9.229,23.627c-0.467,0.464-0.375,0.649,0,0.928
+			l15.522,15.506c0.095,0.094,0.373,0.094,0.373-0.094v-9.281h12.718c0.28,0,0.467-0.188,0.467-0.373v-12.35
+			c0-0.371-0.187-0.463-0.562-0.463H25.124L25.219,8.124z"/>
+		<path fill="#2F62E3" d="M25.208,8.15c0-0.279-0.278-0.279-0.467-0.186L9.245,23.628c-0.466,0.463-0.374,0.648,0,0.927
+			l15.499,15.479c0.094,0.093,0.373,0.093,0.373-0.095v-9.268h12.695c0.28,0,0.469-0.186,0.469-0.371V17.975
+			c0-0.371-0.188-0.463-0.562-0.463H25.116L25.208,8.15z"/>
+		<path fill="#3063E4" d="M25.2,8.177c0-0.278-0.279-0.278-0.468-0.185L9.259,23.628c-0.465,0.462-0.373,0.647,0,0.925l15.476,15.45
+			c0.094,0.093,0.373,0.093,0.373-0.092V30.66h12.678c0.279,0,0.467-0.188,0.467-0.371V17.984c0-0.37-0.188-0.462-0.561-0.462
+			H25.105L25.2,8.177z"/>
+		<path fill="#3164E4" d="M25.189,8.204c0-0.277-0.278-0.277-0.465-0.185L9.273,23.629c-0.465,0.462-0.373,0.646,0,0.924
+			l15.452,15.426c0.092,0.092,0.371,0.092,0.371-0.092v-9.238h12.658c0.279,0,0.467-0.187,0.467-0.371V17.995
+			c0-0.37-0.188-0.461-0.561-0.461H25.098L25.189,8.204z"/>
+		<path fill="#3265E5" d="M25.182,8.229c0-0.277-0.279-0.277-0.466-0.185L9.289,23.629c-0.464,0.461-0.372,0.645,0,0.921
+			l15.428,15.4c0.094,0.093,0.372,0.093,0.372-0.093v-9.217h12.64c0.276,0,0.465-0.188,0.465-0.369V18.004
+			c0-0.369-0.188-0.46-0.559-0.46H25.087L25.182,8.229z"/>
+		<path fill="#3366E5" d="M25.171,8.256c0-0.276-0.278-0.276-0.465-0.184L9.304,23.63c-0.463,0.46-0.372,0.644,0,0.92l15.404,15.373
+			c0.093,0.093,0.371,0.093,0.371-0.092v-9.205h12.619c0.276,0,0.465-0.185,0.465-0.369V18.015c0-0.368-0.188-0.459-0.56-0.459
+			H25.079L25.171,8.256z"/>
+		<path fill="#3366E6" d="M25.161,8.284c0-0.276-0.276-0.276-0.463-0.184L9.317,23.631c-0.462,0.459-0.371,0.643,0,0.919
+			l15.381,15.347c0.094,0.095,0.37,0.095,0.37-0.09v-9.188h12.601c0.279,0,0.466-0.187,0.466-0.368V18.024
+			c0-0.367-0.187-0.458-0.558-0.458H25.068L25.161,8.284z"/>
+		<path fill="#3467E6" d="M25.15,8.311c0-0.276-0.276-0.276-0.463-0.184L9.332,23.631c-0.462,0.459-0.371,0.642,0,0.917
+			L24.688,39.87c0.096,0.091,0.371,0.091,0.371-0.093v-9.174h12.582c0.276,0,0.463-0.187,0.463-0.369V18.035
+			c0-0.367-0.187-0.458-0.558-0.458H25.059L25.15,8.311z"/>
+		<path fill="#3568E7" d="M25.143,8.336c0-0.275-0.277-0.275-0.463-0.183L9.347,23.632c-0.461,0.458-0.37,0.641,0,0.917
+			L24.68,39.846c0.094,0.092,0.37,0.092,0.37-0.093v-9.157h12.562c0.277,0,0.463-0.186,0.463-0.367V18.044
+			c0-0.366-0.186-0.457-0.555-0.457H25.05L25.143,8.336z"/>
+		<path fill="#3669E7" d="M25.133,8.364c0-0.275-0.277-0.275-0.462-0.183L9.361,23.632c-0.461,0.458-0.369,0.64,0,0.916
+			l15.31,15.271c0.095,0.093,0.369,0.093,0.369-0.09v-9.146h12.543c0.276,0,0.463-0.185,0.463-0.367V18.055
+			c0-0.365-0.187-0.456-0.555-0.456H25.04L25.133,8.364z"/>
+		<path fill="#376AE8" d="M25.122,8.39c0-0.274-0.274-0.274-0.461-0.183L9.375,23.633c-0.459,0.457-0.368,0.639,0,0.914
+			L24.663,39.79c0.092,0.091,0.366,0.091,0.366-0.091V30.57h12.525c0.275,0,0.461-0.184,0.461-0.364V18.064
+			c0-0.365-0.186-0.455-0.555-0.455H25.029L25.122,8.39z"/>
+		<path fill="#386BE8" d="M25.113,8.417c0-0.274-0.276-0.274-0.461-0.183L9.39,23.634c-0.459,0.456-0.368,0.638,0,0.912
+			l15.262,15.218c0.095,0.09,0.369,0.09,0.369-0.091v-9.112h12.504c0.275,0,0.461-0.184,0.461-0.365v-12.12
+			c0-0.364-0.186-0.455-0.553-0.455H25.021L25.113,8.417z"/>
+		<path fill="#396CE9" d="M25.104,8.442c0-0.273-0.273-0.273-0.459-0.182L9.405,23.636c-0.458,0.455-0.368,0.636,0,0.909
+			l15.24,15.189c0.092,0.093,0.367,0.093,0.367-0.09v-9.097h12.485c0.274,0,0.459-0.183,0.459-0.364v-12.1
+			c0-0.363-0.185-0.454-0.552-0.454H25.012L25.104,8.442z"/>
+		<path fill="#3A6DE9" d="M25.094,8.47c0-0.273-0.273-0.273-0.457-0.182L9.419,23.636c-0.458,0.455-0.367,0.636,0,0.908
+			l15.216,15.165c0.092,0.091,0.367,0.091,0.367-0.09v-9.081h12.466c0.274,0,0.459-0.185,0.459-0.364V18.096
+			c0-0.363-0.185-0.453-0.552-0.453H25.003L25.094,8.47z"/>
+		<path fill="#3B6EEA" d="M25.085,8.497c0-0.272-0.274-0.272-0.459-0.181L9.435,23.637c-0.457,0.453-0.366,0.634,0,0.906
+			l15.193,15.141c0.093,0.09,0.365,0.09,0.365-0.092v-9.064h12.446c0.271,0,0.457-0.182,0.457-0.361v-12.06
+			c0-0.362-0.186-0.452-0.549-0.452H24.993L25.085,8.497z"/>
+		<path fill="#3C6FEA" d="M25.075,8.522c0-0.272-0.272-0.272-0.457-0.181L9.449,23.637c-0.457,0.453-0.366,0.633,0,0.905
+			l15.169,15.112c0.092,0.091,0.362,0.091,0.362-0.09v-9.051h12.431c0.272,0,0.457-0.183,0.457-0.363V18.116
+			c0-0.362-0.185-0.452-0.55-0.452H24.982L25.075,8.522z"/>
+		<path fill="#3D70EB" d="M25.064,8.549c0-0.271-0.272-0.271-0.455-0.181L9.462,23.638c-0.455,0.452-0.365,0.632,0,0.903
+			l15.147,15.087c0.093,0.093,0.363,0.093,0.363-0.089v-9.035h12.409c0.272,0,0.456-0.181,0.456-0.359v-12.02
+			c0-0.361-0.184-0.451-0.549-0.451H24.975L25.064,8.549z"/>
+		<path fill="#3E71EB" d="M25.057,8.577c0-0.271-0.273-0.271-0.455-0.181L9.478,23.639c-0.455,0.451-0.364,0.631,0,0.901
+			l15.124,15.062c0.09,0.09,0.362,0.09,0.362-0.09v-9.021h12.392c0.272,0,0.455-0.183,0.455-0.361V18.136
+			c0-0.36-0.183-0.45-0.547-0.45h-12.3L25.057,8.577z"/>
+		<path fill="#3F72EC" d="M25.046,8.603c0-0.27-0.272-0.27-0.455-0.18L9.493,23.639c-0.454,0.45-0.364,0.63,0,0.9l15.099,15.035
+			c0.092,0.09,0.364,0.09,0.364-0.09V30.48h12.369c0.272,0,0.454-0.183,0.454-0.359V18.146c0-0.36-0.182-0.449-0.547-0.449H24.956
+			L25.046,8.603z"/>
+		<path fill="#4073EC" d="M25.038,8.629c0-0.27-0.272-0.27-0.455-0.18L9.506,23.64c-0.453,0.45-0.363,0.629,0,0.898l15.075,15.01
+			c0.092,0.091,0.362,0.091,0.362-0.09v-8.985h12.353c0.272,0,0.455-0.183,0.455-0.361V18.157c0-0.359-0.183-0.448-0.545-0.448
+			H24.945L25.038,8.629z"/>
+		<path fill="#4174ED" d="M25.027,8.656c0-0.269-0.272-0.269-0.454-0.179L9.521,23.641c-0.453,0.449-0.363,0.627,0,0.896
+			L24.573,39.52c0.092,0.09,0.362,0.09,0.362-0.09v-8.972h12.332c0.271,0,0.453-0.181,0.453-0.36V18.166
+			c0-0.358-0.182-0.447-0.544-0.447H24.938L25.027,8.656z"/>
+		<path fill="#4275ED" d="M25.018,8.683c0-0.269-0.271-0.269-0.453-0.179L9.537,23.641c-0.452,0.448-0.362,0.626,0,0.896
+			l15.027,14.957c0.092,0.09,0.362,0.09,0.362-0.09v-8.955h12.312c0.271,0,0.453-0.18,0.453-0.359V18.177
+			c0-0.358-0.182-0.447-0.543-0.447H24.927L25.018,8.683z"/>
+		<path fill="#4376EE" d="M25.008,8.709c0-0.269-0.271-0.269-0.451-0.179L9.551,23.642c-0.451,0.447-0.361,0.625,0,0.895
+			l15.006,14.932c0.09,0.09,0.36,0.09,0.36-0.089v-8.94H37.21c0.271,0,0.453-0.18,0.453-0.356V18.187
+			c0-0.357-0.183-0.446-0.543-0.446H24.917L25.008,8.709z"/>
+		<path fill="#4477EE" d="M24.997,8.735c0-0.268-0.271-0.268-0.45-0.179L9.564,23.642c-0.45,0.446-0.361,0.625,0,0.893
+			l14.982,14.904c0.091,0.09,0.36,0.09,0.36-0.088v-8.928H37.18c0.271,0,0.451-0.179,0.451-0.355V18.197
+			c0-0.356-0.181-0.445-0.542-0.445h-12.18L24.997,8.735z"/>
+		<path fill="#4578EF" d="M24.988,8.763c0-0.268-0.271-0.268-0.449-0.178L9.58,23.643c-0.449,0.445-0.36,0.623,0,0.891l14.958,14.88
+			c0.09,0.089,0.358,0.089,0.358-0.089v-8.909h12.256c0.271,0,0.451-0.18,0.451-0.357V18.207c0-0.356-0.182-0.444-0.541-0.444
+			H24.898L24.988,8.763z"/>
+		<path fill="#4679EF" d="M24.979,8.79c0-0.267-0.271-0.267-0.449-0.178L9.595,23.644c-0.449,0.445-0.36,0.622,0,0.891
+			l14.934,14.851c0.091,0.091,0.359,0.091,0.359-0.088v-8.896h12.234c0.271,0,0.451-0.18,0.451-0.355V18.216
+			c0-0.355-0.184-0.443-0.541-0.443H24.891L24.979,8.79z"/>
+		<path fill="#477AF0" d="M24.971,8.815c0-0.267-0.271-0.267-0.451-0.178L9.608,23.644c-0.448,0.444-0.359,0.621,0,0.889
+			L24.52,39.357c0.09,0.09,0.36,0.09,0.36-0.088v-8.879h12.218c0.27,0,0.448-0.18,0.448-0.354V18.228
+			c0-0.355-0.183-0.443-0.541-0.443H24.88L24.971,8.815z"/>
+		<path fill="#487BF0" d="M24.96,8.842c0-0.266-0.271-0.266-0.448-0.177L9.624,23.645c-0.448,0.443-0.359,0.62,0,0.888
+			l14.888,14.801c0.09,0.088,0.358,0.088,0.358-0.088v-8.863h12.196c0.271,0,0.449-0.178,0.449-0.355v-11.79
+			c0-0.354-0.182-0.442-0.539-0.442H24.87L24.96,8.842z"/>
+		<path fill="#497CF1" d="M24.95,8.87c0-0.266-0.269-0.266-0.447-0.177L9.638,23.645c-0.447,0.442-0.358,0.619,0,0.886
+			l14.865,14.773c0.09,0.09,0.356,0.09,0.356-0.09v-8.846H37.04c0.271,0,0.446-0.18,0.446-0.354V18.248
+			c0-0.353-0.18-0.441-0.536-0.441H24.859L24.95,8.87z"/>
+		<path fill="#4A7DF1" d="M24.939,8.896c0-0.265-0.268-0.265-0.446-0.177L9.652,23.646c-0.446,0.442-0.357,0.618,0,0.883
+			l14.841,14.75c0.089,0.088,0.358,0.088,0.358-0.088v-8.832H37.01c0.27,0,0.448-0.178,0.448-0.354V18.257
+			c0-0.353-0.183-0.44-0.537-0.44H24.852L24.939,8.896z"/>
+		<path fill="#4B7EF2" d="M24.932,8.922c0-0.265-0.269-0.265-0.447-0.177L9.667,23.646c-0.445,0.441-0.357,0.617,0,0.881
+			l14.818,14.724c0.089,0.088,0.357,0.088,0.357-0.088V30.35h12.141c0.268,0,0.447-0.18,0.447-0.354V18.268
+			c0-0.353-0.181-0.44-0.537-0.44H24.842L24.932,8.922z"/>
+		<path fill="#4C7FF2" d="M24.921,8.949c0-0.264-0.269-0.264-0.445-0.176L9.682,23.646c-0.444,0.44-0.356,0.616,0,0.879
+			l14.794,14.697c0.088,0.088,0.355,0.088,0.355-0.089v-8.801h12.121c0.269,0,0.444-0.177,0.444-0.354V18.277
+			c0-0.352-0.18-0.438-0.535-0.438h-12.03L24.921,8.949z"/>
+		<path fill="#4D80F3" d="M24.913,8.976c0-0.264-0.269-0.264-0.444-0.176L9.697,23.647c-0.444,0.439-0.356,0.615,0,0.878
+			l14.771,14.672c0.091,0.088,0.355,0.088,0.355-0.088v-8.784h12.102c0.269,0,0.445-0.179,0.445-0.354V18.288
+			c0-0.351-0.181-0.438-0.535-0.438H24.823L24.913,8.976z"/>
+		<path fill="#4E81F3" d="M24.902,9.002c0-0.264-0.268-0.264-0.444-0.176L9.71,23.647c-0.443,0.439-0.355,0.614,0,0.876
+			L24.458,39.17c0.089,0.088,0.354,0.088,0.354-0.087v-8.771h12.082c0.268,0,0.444-0.176,0.444-0.354V18.297
+			c0-0.35-0.178-0.437-0.532-0.437H24.812L24.902,9.002z"/>
+		<path fill="#4F82F4" d="M24.895,9.028c0-0.263-0.269-0.263-0.444-0.175L9.726,23.648c-0.442,0.438-0.354,0.612,0,0.875
+			L24.45,39.145c0.089,0.088,0.354,0.088,0.354-0.086v-8.754h12.062c0.267,0,0.442-0.178,0.442-0.354V18.308
+			c0-0.349-0.18-0.436-0.533-0.436H24.805L24.895,9.028z"/>
+		<path fill="#5083F4" d="M24.884,9.056c0-0.262-0.268-0.262-0.443-0.175L9.74,23.649c-0.441,0.437-0.354,0.611,0,0.875l14.7,14.595
+			c0.089,0.087,0.354,0.087,0.354-0.087v-8.737h12.045c0.267,0,0.44-0.176,0.44-0.353V18.317c0-0.349-0.178-0.436-0.53-0.436H24.794
+			L24.884,9.056z"/>
+		<path fill="#5184F5" d="M24.874,9.082c0-0.262-0.269-0.262-0.442-0.175L9.754,23.649c-0.441,0.437-0.354,0.61,0,0.873
+			l14.677,14.566c0.088,0.088,0.354,0.088,0.354-0.086v-8.723h12.025c0.266,0,0.44-0.176,0.44-0.35V18.329
+			c0-0.348-0.176-0.435-0.53-0.435H24.786L24.874,9.082z"/>
+		<path fill="#5285F5" d="M24.863,9.108c0-0.262-0.264-0.262-0.44-0.174L9.769,23.65c-0.44,0.436-0.353,0.609,0,0.872l14.654,14.541
+			c0.089,0.086,0.353,0.086,0.353-0.086V30.27h12.008c0.264,0,0.439-0.176,0.439-0.351V18.338c0-0.348-0.177-0.434-0.529-0.434
+			H24.775L24.863,9.108z"/>
+		<path fill="#5386F6" d="M24.854,9.136c0-0.261-0.266-0.261-0.44-0.174l-14.63,14.69c-0.439,0.435-0.353,0.608,0,0.87l14.63,14.517
+			c0.089,0.087,0.353,0.087,0.353-0.086V30.26H36.75c0.266,0,0.439-0.175,0.439-0.349V18.349c0-0.347-0.176-0.433-0.527-0.433
+			H24.768L24.854,9.136z"/>
+		<path fill="#5487F6" d="M24.846,9.163c0-0.261-0.265-0.261-0.441-0.174L9.798,23.651c-0.439,0.434-0.352,0.607,0,0.867
+			l14.606,14.49c0.088,0.086,0.352,0.086,0.352-0.086v-8.676h11.967c0.264,0,0.439-0.176,0.439-0.35V18.358
+			c0-0.346-0.178-0.432-0.527-0.432H24.757L24.846,9.163z"/>
+		<path fill="#5588F7" d="M24.835,9.188c0-0.26-0.265-0.26-0.439-0.173L9.812,23.652c-0.438,0.433-0.352,0.606,0,0.866L24.395,38.98
+			c0.088,0.088,0.352,0.088,0.352-0.086v-8.66h11.946c0.265,0,0.439-0.174,0.439-0.348V18.369c0-0.346-0.178-0.432-0.527-0.432
+			H24.747L24.835,9.188z"/>
+		<path fill="#5689F7" d="M24.827,9.215c0-0.26-0.265-0.26-0.438-0.173L9.828,23.653c-0.437,0.432-0.351,0.604,0,0.865l14.56,14.438
+			c0.088,0.086,0.352,0.086,0.352-0.086v-8.646h11.928c0.266,0,0.438-0.176,0.438-0.349v-11.5c0-0.345-0.176-0.431-0.525-0.431
+			H24.74L24.827,9.215z"/>
+		<path fill="#578AF8" d="M24.816,9.242c0-0.259-0.264-0.259-0.438-0.172L9.842,23.653c-0.437,0.432-0.35,0.604,0,0.863
+			l14.537,14.41c0.088,0.086,0.35,0.086,0.35-0.086v-8.629h11.91c0.262,0,0.438-0.173,0.438-0.346V18.389
+			c0-0.344-0.176-0.43-0.524-0.43H24.729L24.816,9.242z"/>
+		<path fill="#588BF8" d="M24.807,9.269c0-0.259-0.262-0.259-0.437-0.172L9.856,23.655c-0.436,0.431-0.35,0.603,0,0.863
+			L24.37,38.898c0.088,0.086,0.349,0.086,0.349-0.084v-8.612h11.891c0.264,0,0.438-0.175,0.438-0.347V18.398
+			c0-0.344-0.176-0.429-0.524-0.429H24.719L24.807,9.269z"/>
+		<path fill="#598CF9" d="M24.796,9.294c0-0.258-0.261-0.258-0.438-0.172L9.872,23.655c-0.435,0.43-0.349,0.602,0,0.861
+			L24.36,38.872c0.088,0.086,0.35,0.086,0.35-0.085v-8.602h11.871c0.263,0,0.438-0.172,0.438-0.344V18.41
+			c0-0.343-0.177-0.429-0.522-0.429H24.71L24.796,9.294z"/>
+		<path fill="#5A8DF9" d="M24.788,9.322c0-0.258-0.263-0.258-0.437-0.172L9.886,23.656c-0.435,0.429-0.349,0.6,0,0.857
+			l14.466,14.334c0.088,0.086,0.349,0.086,0.349-0.088v-8.58h11.854c0.262,0,0.438-0.174,0.438-0.346V18.418
+			c0-0.342-0.177-0.427-0.522-0.427H24.7L24.788,9.322z"/>
+		<path fill="#5B8EFA" d="M24.777,9.349c0-0.257-0.262-0.257-0.436-0.171L9.9,23.657c-0.434,0.428-0.348,0.6,0,0.856L24.342,38.82
+			c0.087,0.086,0.348,0.086,0.348-0.084v-8.567h11.834c0.261,0,0.437-0.172,0.437-0.344V18.43c0-0.342-0.176-0.427-0.522-0.427
+			H24.689L24.777,9.349z"/>
+		<path fill="#5C8FFA" d="M24.77,9.375c0-0.257-0.262-0.257-0.436-0.171L9.915,23.657c-0.433,0.428-0.348,0.599,0,0.854
+			l14.419,14.281c0.087,0.086,0.348,0.086,0.348-0.085v-8.551h11.812c0.262,0,0.438-0.174,0.438-0.346V18.439
+			c0-0.341-0.176-0.426-0.521-0.426H24.682L24.77,9.375z"/>
+		<path fill="#5D90FB" d="M24.759,9.401c0-0.256-0.26-0.256-0.434-0.17L9.93,23.658c-0.432,0.427-0.347,0.597,0,0.855l14.396,14.254
+			c0.087,0.086,0.347,0.086,0.347-0.084v-8.537h11.794c0.26,0,0.436-0.172,0.436-0.342V18.45c0-0.341-0.176-0.425-0.521-0.425
+			h-11.71L24.759,9.401z"/>
+		<path fill="#5E91FB" d="M24.749,9.429c0-0.256-0.26-0.256-0.435-0.17l-14.371,14.4c-0.432,0.426-0.346,0.596,0,0.852L24.315,38.74
+			c0.087,0.085,0.346,0.085,0.346-0.086v-8.521h11.774c0.26,0,0.435-0.172,0.435-0.342V18.459c0-0.34-0.175-0.424-0.521-0.424
+			H24.663L24.749,9.429z"/>
+		<path fill="#5F92FC" d="M24.741,9.455c0-0.255-0.261-0.255-0.434-0.17L9.958,23.659c-0.431,0.425-0.346,0.595,0,0.851
+			l14.349,14.202c0.087,0.085,0.345,0.085,0.345-0.084v-8.505h11.757c0.258,0,0.434-0.171,0.434-0.341V18.47
+			c0-0.339-0.176-0.423-0.521-0.423h-11.67L24.741,9.455z"/>
+		<path fill="#6093FC" d="M24.73,9.481c0-0.255-0.259-0.255-0.433-0.17L9.974,23.66c-0.43,0.425-0.345,0.594,0,0.849l14.325,14.179
+			c0.087,0.084,0.346,0.084,0.346-0.084v-8.489H36.38c0.259,0,0.433-0.171,0.433-0.341V18.479c0-0.339-0.174-0.423-0.521-0.423
+			H24.645L24.73,9.481z"/>
+		<path fill="#6194FD" d="M24.721,9.507c0-0.254-0.259-0.254-0.431-0.169L9.988,23.661c-0.43,0.424-0.345,0.593,0,0.847
+			l14.302,14.15c0.086,0.085,0.344,0.085,0.344-0.084V30.1h11.718c0.258,0,0.432-0.17,0.432-0.342v-11.27
+			c0-0.338-0.174-0.422-0.518-0.422H24.634L24.721,9.507z"/>
+		<path fill="#6295FD" d="M24.71,9.535c0-0.254-0.257-0.254-0.429-0.169L10.002,23.661c-0.429,0.423-0.344,0.592,0,0.846
+			L24.28,38.631c0.086,0.085,0.343,0.085,0.343-0.083V30.09H36.32c0.258,0,0.432-0.17,0.432-0.34V18.5
+			c0-0.337-0.174-0.421-0.52-0.421H24.623L24.71,9.535z"/>
+		<path fill="#6396FE" d="M24.702,9.561c0-0.253-0.259-0.253-0.43-0.169l-14.256,14.27c-0.428,0.422-0.343,0.591,0,0.844
+			l14.255,14.1c0.086,0.084,0.342,0.084,0.342-0.084V30.08h11.681c0.258,0,0.431-0.17,0.431-0.338v-11.23
+			c0-0.337-0.173-0.42-0.517-0.42H24.616L24.702,9.561z"/>
+		<path fill="#6497FE" d="M24.691,9.587c0-0.253-0.257-0.253-0.429-0.168l-14.23,14.243c-0.427,0.422-0.343,0.59,0,0.843
+			l14.231,14.072c0.086,0.084,0.342,0.084,0.342-0.083v-8.428h11.66c0.258,0,0.43-0.17,0.43-0.338V18.521
+			c0-0.336-0.172-0.42-0.516-0.42H24.605L24.691,9.587z"/>
+		<path fill="#6598FF" d="M24.684,9.615c0-0.252-0.258-0.252-0.43-0.168L10.045,23.663c-0.426,0.42-0.342,0.588,0,0.841
+			l14.208,14.047c0.086,0.084,0.343,0.084,0.343-0.084v-8.41h11.641c0.257,0,0.429-0.168,0.429-0.336V18.531
+			c0-0.335-0.172-0.418-0.515-0.418H24.598L24.684,9.615z"/>
+		<path fill="#6699FF" d="M24.673,9.642c0-0.252-0.257-0.252-0.428-0.168L10.06,23.664c-0.426,0.42-0.342,0.587,0,0.839
+			l14.185,14.021c0.086,0.084,0.342,0.084,0.342-0.084v-8.396h11.621c0.256,0,0.429-0.169,0.429-0.337V18.541
+			c0-0.335-0.173-0.418-0.515-0.418H24.587L24.673,9.642z"/>
+	</g>
+	
+		<linearGradient id="XMLID_16_" gradientUnits="userSpaceOnUse" x1="-1112.2041" y1="1225.4229" x2="-1112.2041" y2="1254.5781" gradientTransform="matrix(-1 0 0 1 -1089 -1216)">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="1" style="stop-color:#6699FF"/>
+	</linearGradient>
+	<path fill="url(#XMLID_16_)" d="M24.673,9.642c0-0.252-0.257-0.252-0.428-0.168L10.06,23.664c-0.426,0.42-0.342,0.587,0,0.839
+		l14.185,14.021c0.086,0.084,0.342,0.084,0.342-0.084v-8.396h11.621c0.256,0,0.429-0.169,0.429-0.337V18.541
+		c0-0.335-0.173-0.418-0.515-0.418H24.587L24.673,9.642z"/>
+</g>
+<g id="crop_x0020_marks">
+	<path fill="none" d="M-0.06,0.001h48v48h-48V0.001z"/>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/tip.svg b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/tip.svg
new file mode 100644
index 0000000..7ec92e3
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/tip.svg
@@ -0,0 +1,367 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.1" id="Tip" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="48" height="48" viewBox="0 0 48 48"
+	 overflow="visible" enable-background="new 0 0 48 48" xml:space="preserve">
+<g>
+	<path stroke="#FFFFFF" stroke-width="5.6139" d="M9.525,18.6c0,8,6.5,14.4,14.4,14.4c8.001,0,14.399-6.5,14.399-14.4
+		c0-8-6.5-14.4-14.399-14.4C15.925,4.2,9.525,10.7,9.525,18.6z M12.825,18.6c0-6.2,5-11.2,11.2-11.2c6.2,0,11.2,5,11.2,11.2
+		c0,6.2-5,11.2-11.2,11.2C17.825,29.8,12.825,24.8,12.825,18.6z"/>
+	<path stroke="#FFFFFF" stroke-width="5.6139" d="M28.125,37.9l-7.6,0.8c-0.9,0.1-1.5,0.899-1.4,1.8s0.9,1.5,1.8,1.4l7.601-0.801
+		c0.9-0.102,1.5-0.899,1.4-1.802C29.824,38.4,29.025,37.8,28.125,37.9z"/>
+	<path stroke="#FFFFFF" stroke-width="5.6139" d="M28.125,34.8l-7.6,0.8c-0.9,0.101-1.5,0.9-1.4,1.801c0.1,0.897,0.9,1.5,1.8,1.397
+		l7.601-0.8c0.9-0.102,1.5-0.898,1.4-1.8C29.824,35.3,29.025,34.7,28.125,34.8z"/>
+	<path stroke="#FFFFFF" stroke-width="5.6139" d="M28.125,31.6l-7.6,0.801c-0.9,0.1-1.5,0.897-1.4,1.8c0.1,0.899,0.9,1.5,1.8,1.399
+		l7.601-0.802c0.9-0.1,1.5-0.897,1.4-1.8C29.824,32.1,29.025,31.5,28.125,31.6z"/>
+	<path stroke="#FFFFFF" stroke-width="5.6139" d="M23.125,41.3v0.9c0,0.899,0.7,1.6,1.6,1.6c0.9,0,1.6-0.7,1.6-1.6v-0.9h-3.299
+		H23.125z"/>
+	<path fill="#FFFFFF" d="M35.926,18.7c0,6.6-5.4,12-12.001,12c-6.6,0-12-5.4-12-12c0-6.6,5.4-12,12-12
+		C30.525,6.7,35.926,12.1,35.926,18.7z"/>
+	<g>
+		<path fill="#FFFF00" d="M9.625,18.6c0,8,6.5,14.4,14.4,14.4c8,0,14.401-6.5,14.401-14.4c0-8-6.5-14.4-14.401-14.4
+			C16.025,4.2,9.625,10.7,9.625,18.6z"/>
+		<path fill="#FFFF01" d="M9.647,18.6c0-7.889,6.391-14.379,14.379-14.379c7.89,0,14.378,6.391,14.378,14.379
+			c0,7.889-6.391,14.378-14.378,14.378C16.137,32.979,9.647,26.588,9.647,18.6z"/>
+		<path fill="#FFFF02" d="M9.668,18.6c0-7.878,6.382-14.358,14.358-14.358c7.878,0,14.359,6.382,14.359,14.358
+			c0,7.876-6.383,14.358-14.359,14.358C16.149,32.958,9.668,26.576,9.668,18.6z"/>
+		<path fill="#FFFF03" d="M9.69,18.6c0-7.867,6.373-14.337,14.337-14.337c7.868,0,14.338,6.373,14.338,14.337
+			c0,7.867-6.373,14.337-14.338,14.337C16.16,32.938,9.69,26.564,9.69,18.6z"/>
+		<path fill="#FFFF04" d="M9.712,18.6c0-7.855,6.363-14.316,14.316-14.316c7.855,0,14.316,6.363,14.316,14.316
+			c0,7.856-6.363,14.316-14.316,14.316C16.172,32.916,9.712,26.553,9.712,18.6z"/>
+		<path fill="#FFFF05" d="M9.733,18.6c0-7.844,6.354-14.295,14.295-14.295c7.847,0,14.296,6.354,14.296,14.295
+			c0,7.843-6.354,14.294-14.296,14.294C16.184,32.896,9.733,26.541,9.733,18.6z"/>
+		<path fill="#FFFF06" d="M9.754,18.6c0-7.833,6.345-14.274,14.274-14.274c7.833,0,14.275,6.345,14.275,14.274
+			c0,7.833-6.346,14.274-14.275,14.274C16.196,32.874,9.754,26.529,9.754,18.6z"/>
+		<path fill="#FFFF07" d="M9.776,18.6c0-7.822,6.336-14.253,14.254-14.253c7.822,0,14.253,6.335,14.253,14.253
+			c0,7.823-6.336,14.253-14.253,14.253C16.208,32.854,9.776,26.518,9.776,18.6z"/>
+		<path fill="#FFFF08" d="M9.798,18.6c0-7.811,6.326-14.232,14.232-14.232c7.812,0,14.234,6.326,14.234,14.232
+			c0,7.811-6.328,14.233-14.234,14.233C16.219,32.833,9.798,26.506,9.798,18.6z"/>
+		<path fill="#FFFF09" d="M9.819,18.6c0-7.8,6.317-14.211,14.211-14.211c7.8,0,14.212,6.317,14.212,14.211
+			c0,7.8-6.318,14.21-14.212,14.21C16.231,32.812,9.819,26.494,9.819,18.6z"/>
+		<path fill="#FFFF0A" d="M9.84,18.6c0-7.789,6.309-14.191,14.191-14.191c7.79,0,14.192,6.309,14.192,14.191
+			c0,7.789-6.309,14.191-14.192,14.191C16.243,32.791,9.84,26.482,9.84,18.6z"/>
+		<path fill="#FFFF0B" d="M9.862,18.6c0-7.778,6.299-14.17,14.17-14.17c7.779,0,14.169,6.299,14.169,14.17
+			c0,7.778-6.299,14.169-14.169,14.169C16.254,32.77,9.862,26.471,9.862,18.6z"/>
+		<path fill="#FFFF0C" d="M9.884,18.6c0-7.767,6.29-14.149,14.149-14.149c7.768,0,14.149,6.29,14.149,14.149
+			c0,7.767-6.291,14.149-14.149,14.149C16.266,32.749,9.884,26.459,9.884,18.6z"/>
+		<path fill="#FFFF0D" d="M9.905,18.6c0-7.756,6.281-14.128,14.128-14.128c7.756,0,14.129,6.281,14.129,14.128
+			c0,7.755-6.281,14.128-14.129,14.128C16.278,32.729,9.905,26.447,9.905,18.6z"/>
+		<path fill="#FFFF0E" d="M9.927,18.6c0-7.745,6.272-14.107,14.107-14.107c7.746,0,14.107,6.272,14.107,14.107
+			c0,7.746-6.27,14.107-14.107,14.107C16.29,32.707,9.927,26.436,9.927,18.6z"/>
+		<path fill="#FFFF0F" d="M9.949,18.6c0-7.733,6.263-14.086,14.086-14.086c7.733,0,14.088,6.262,14.088,14.086
+			c0,7.733-6.266,14.085-14.088,14.085C16.302,32.688,9.949,26.423,9.949,18.6z"/>
+		<path fill="#FFFF10" d="M9.97,18.6c0-7.722,6.253-14.065,14.065-14.065c7.723,0,14.067,6.253,14.067,14.065
+			c0,7.722-6.254,14.066-14.067,14.066C16.313,32.666,9.97,26.411,9.97,18.6z"/>
+		<path fill="#FFFF11" d="M9.992,18.6c0-7.711,6.244-14.044,14.044-14.044c7.712,0,14.044,6.245,14.044,14.044
+			c0,7.71-6.244,14.044-14.044,14.044C16.325,32.645,9.992,26.398,9.992,18.6z"/>
+		<path fill="#FFFF12" d="M10.013,18.6c0-7.7,6.235-14.023,14.023-14.023c7.7,0,14.024,6.235,14.024,14.023
+			c0,7.7-6.236,14.023-14.024,14.023C16.337,32.623,10.013,26.389,10.013,18.6z"/>
+		<path fill="#FFFF13" d="M10.035,18.6c0-7.688,6.226-14.002,14.002-14.002c7.689,0,14.004,6.226,14.004,14.002
+			c0,7.689-6.229,14.001-14.004,14.001C16.348,32.604,10.035,26.376,10.035,18.6z"/>
+		<path fill="#FFFF14" d="M10.057,18.6c0-7.678,6.217-13.981,13.981-13.981c7.679,0,13.981,6.217,13.981,13.981
+			c0,7.677-6.217,13.981-13.981,13.981C16.36,32.581,10.057,26.364,10.057,18.6z"/>
+		<path fill="#FFFF15" d="M10.078,18.6c0-7.667,6.208-13.961,13.961-13.961C31.707,4.639,38,10.847,38,18.6
+			c0,7.667-6.209,13.96-13.961,13.96C16.372,32.561,10.078,26.354,10.078,18.6z"/>
+		<path fill="#FFFF16" d="M10.1,18.6c0-7.655,6.198-13.94,13.939-13.94c7.656,0,13.941,6.199,13.941,13.94
+			c0,7.656-6.201,13.94-13.941,13.94C16.384,32.54,10.1,26.341,10.1,18.6z"/>
+		<path fill="#FFFF17" d="M10.121,18.6c0-7.644,6.189-13.919,13.919-13.919c7.646,0,13.919,6.189,13.919,13.919
+			c0,7.644-6.189,13.917-13.919,13.917C16.396,32.52,10.121,26.329,10.121,18.6z"/>
+		<path fill="#FFFF18" d="M10.143,18.6c0-7.633,6.181-13.898,13.898-13.898c7.633,0,13.898,6.18,13.898,13.898
+			c0,7.632-6.182,13.898-13.898,13.898C16.408,32.498,10.143,26.316,10.143,18.6z"/>
+		<path fill="#FFFF19" d="M10.164,18.6c0-7.622,6.171-13.877,13.877-13.877c7.623,0,13.877,6.171,13.877,13.877
+			c0,7.623-6.172,13.876-13.877,13.876C16.419,32.479,10.164,26.307,10.164,18.6z"/>
+		<path fill="#FFFF1A" d="M10.186,18.6c0-7.611,6.162-13.856,13.856-13.856c7.61,0,13.856,6.162,13.856,13.856
+			c0,7.611-6.162,13.856-13.856,13.856C16.431,32.456,10.186,26.294,10.186,18.6z"/>
+		<path fill="#FFFF1B" d="M10.208,18.6c0-7.6,6.153-13.835,13.835-13.835c7.602,0,13.836,6.153,13.836,13.835
+			c0,7.6-6.152,13.835-13.836,13.835C16.443,32.436,10.208,26.282,10.208,18.6z"/>
+		<path fill="#FFFF1C" d="M10.229,18.6c0-7.589,6.144-13.814,13.814-13.814c7.59,0,13.814,6.144,13.814,13.814
+			c0,7.587-6.145,13.814-13.814,13.814C16.454,32.414,10.229,26.271,10.229,18.6z"/>
+		<path fill="#FFFF1D" d="M10.251,18.6c0-7.578,6.135-13.793,13.793-13.793c7.579,0,13.794,6.135,13.794,13.793
+			c0,7.578-6.137,13.792-13.794,13.792C16.466,32.395,10.251,26.259,10.251,18.6z"/>
+		<path fill="#FFFF1E" d="M10.272,18.6c0-7.566,6.125-13.772,13.772-13.772c7.567,0,13.772,6.125,13.772,13.772
+			c0,7.567-6.125,13.773-13.772,13.773C16.478,32.373,10.272,26.247,10.272,18.6z"/>
+		<path fill="#FFFF1F" d="M10.294,18.6c0-7.556,6.116-13.752,13.751-13.752c7.557,0,13.752,6.117,13.752,13.752
+			c0,7.554-6.117,13.751-13.752,13.751C16.49,32.352,10.294,26.234,10.294,18.6z"/>
+		<path fill="#FFFF20" d="M10.315,18.6c0-7.544,6.107-13.731,13.731-13.731c7.544,0,13.731,6.107,13.731,13.731
+			c0,7.544-6.107,13.731-13.731,13.731C16.502,32.331,10.315,26.225,10.315,18.6z"/>
+		<path fill="#FFFF21" d="M10.337,18.6c0-7.533,6.098-13.71,13.709-13.71c7.534,0,13.71,6.098,13.71,13.71
+			c0,7.534-6.1,13.708-13.71,13.708C16.513,32.311,10.337,26.212,10.337,18.6z"/>
+		<path fill="#FFFF22" d="M10.358,18.6c0-7.522,6.088-13.688,13.689-13.688c7.521,0,13.689,6.088,13.689,13.688
+			c0,7.522-6.09,13.689-13.689,13.689C16.525,32.289,10.358,26.199,10.358,18.6z"/>
+		<path fill="#FFFF23" d="M10.38,18.6c0-7.511,6.08-13.668,13.668-13.668c7.511,0,13.669,6.08,13.669,13.668
+			c0,7.511-6.08,13.667-13.669,13.667C16.537,32.268,10.38,26.188,10.38,18.6z"/>
+		<path fill="#FFFF24" d="M10.401,18.6c0-7.5,6.071-13.647,13.647-13.647c7.501,0,13.647,6.07,13.647,13.647
+			c0,7.5-6.07,13.647-13.647,13.647C16.549,32.247,10.401,26.176,10.401,18.6z"/>
+		<path fill="#FFFF25" d="M10.423,18.6c0-7.489,6.062-13.626,13.626-13.626c7.49,0,13.627,6.061,13.627,13.626
+			c0,7.489-6.062,13.625-13.627,13.625C16.56,32.227,10.423,26.164,10.423,18.6z"/>
+		<path fill="#FFFF26" d="M10.445,18.6c0-7.478,6.052-13.605,13.605-13.605c7.478,0,13.606,6.052,13.606,13.605
+			c0,7.478-6.053,13.605-13.606,13.605C16.572,32.205,10.445,26.152,10.445,18.6z"/>
+		<path fill="#FFFF27" d="M10.466,18.6c0-7.467,6.043-13.584,13.584-13.584c7.468,0,13.585,6.043,13.585,13.584
+			c0,7.466-6.043,13.583-13.585,13.583C16.584,32.186,10.466,26.141,10.466,18.6z"/>
+		<path fill="#FFFF28" d="M10.488,18.6c0-7.456,6.034-13.563,13.563-13.563c7.457,0,13.562,6.034,13.562,13.563
+			c0,7.457-6.033,13.563-13.562,13.563C16.596,32.163,10.488,26.129,10.488,18.6z"/>
+		<path fill="#FFFF29" d="M10.509,18.6c0-7.445,6.025-13.542,13.542-13.542c7.445,0,13.543,6.024,13.543,13.542
+			c0,7.444-6.025,13.542-13.543,13.542C16.608,32.143,10.509,26.117,10.509,18.6z"/>
+		<path fill="#FFFF2A" d="M10.531,18.6c0-7.434,6.016-13.522,13.521-13.522c7.435,0,13.521,6.016,13.521,13.522
+			c0,7.433-6.016,13.521-13.521,13.521C16.619,32.121,10.531,26.105,10.531,18.6z"/>
+		<path fill="#FFFF2B" d="M10.552,18.6c0-7.422,6.006-13.501,13.501-13.501c7.422,0,13.502,6.007,13.502,13.501
+			c0,7.421-6.008,13.5-13.502,13.5C16.631,32.102,10.552,26.094,10.552,18.6z"/>
+		<path fill="#FFFF2C" d="M10.574,18.6c0-7.411,5.997-13.479,13.479-13.479c7.412,0,13.48,5.997,13.48,13.479
+			c0,7.411-5.998,13.48-13.48,13.48C16.643,32.08,10.574,26.082,10.574,18.6z"/>
+		<path fill="#FFFF2D" d="M10.596,18.6c0-7.4,5.988-13.458,13.458-13.458c7.401,0,13.46,5.988,13.46,13.458
+			c0,7.4-5.988,13.458-13.46,13.458C16.654,32.059,10.596,26.07,10.596,18.6z"/>
+		<path fill="#FFFF2E" d="M10.617,18.6c0-7.389,5.979-13.438,13.438-13.438c7.389,0,13.438,5.979,13.438,13.438
+			c0,7.389-5.979,13.438-13.438,13.438C16.666,32.038,10.617,26.059,10.617,18.6z"/>
+		<path fill="#FFFF2F" d="M10.639,18.6c0-7.377,5.97-13.417,13.417-13.417c7.377,0,13.417,5.97,13.417,13.417
+			c0,7.376-5.971,13.417-13.417,13.417C16.678,32.018,10.639,26.047,10.639,18.6z"/>
+		<path fill="#FFFF30" d="M10.66,18.6c0-7.366,5.96-13.396,13.396-13.396c7.368,0,13.395,5.961,13.395,13.396
+			c0,7.367-5.961,13.396-13.395,13.396C16.69,31.996,10.66,26.035,10.66,18.6z"/>
+		<path fill="#FFFF31" d="M10.682,18.6c0-7.355,5.951-13.375,13.375-13.375c7.355,0,13.375,5.952,13.375,13.375
+			c0,7.355-5.951,13.375-13.375,13.375C16.701,31.977,10.682,26.023,10.682,18.6z"/>
+		<path fill="#FFFF32" d="M10.703,18.6c0-7.344,5.943-13.354,13.354-13.354c7.343,0,13.355,5.943,13.355,13.354
+			c0,7.343-5.943,13.354-13.355,13.354C16.713,31.954,10.703,26.012,10.703,18.6z"/>
+		<path fill="#FFFF33" d="M10.725,18.6c0-7.333,5.933-13.333,13.333-13.333c7.334,0,13.334,5.934,13.334,13.333
+			c0,7.333-5.934,13.333-13.334,13.333C16.725,31.934,10.725,26,10.725,18.6z"/>
+		<path fill="#FFFF34" d="M10.747,18.6c0-7.322,5.924-13.312,13.312-13.312c7.322,0,13.312,5.924,13.312,13.312
+			c0,7.322-5.926,13.312-13.312,13.312C16.737,31.912,10.747,25.988,10.747,18.6z"/>
+		<path fill="#FFFF35" d="M10.768,18.6c0-7.311,5.915-13.292,13.292-13.292c7.311,0,13.292,5.915,13.292,13.292
+			c0,7.311-5.914,13.292-13.292,13.292C16.749,31.893,10.768,25.977,10.768,18.6z"/>
+		<path fill="#FFFF36" d="M10.79,18.6c0-7.3,5.906-13.271,13.271-13.271c7.3,0,13.271,5.906,13.271,13.271
+			c0,7.298-5.904,13.27-13.271,13.27C16.76,31.87,10.79,25.964,10.79,18.6z"/>
+		<path fill="#FFFF37" d="M10.811,18.6c0-7.289,5.897-13.25,13.25-13.25c7.289,0,13.25,5.896,13.25,13.25
+			c0,7.289-5.896,13.25-13.25,13.25C16.772,31.85,10.811,25.952,10.811,18.6z"/>
+		<path fill="#FFFF38" d="M10.833,18.6c0-7.278,5.888-13.229,13.229-13.229c7.278,0,13.229,5.887,13.229,13.229
+			c0,7.278-5.889,13.228-13.229,13.228C16.784,31.828,10.833,25.939,10.833,18.6z"/>
+		<path fill="#FFFF39" d="M10.854,18.6c0-7.267,5.878-13.208,13.208-13.208c7.268,0,13.208,5.878,13.208,13.208
+			c0,7.266-5.877,13.208-13.208,13.208C16.796,31.809,10.854,25.93,10.854,18.6z"/>
+		<path fill="#FFFF3A" d="M10.876,18.6c0-7.255,5.869-13.187,13.187-13.187c7.255,0,13.187,5.869,13.187,13.187
+			c0,7.255-5.869,13.187-13.187,13.187C16.807,31.787,10.876,25.917,10.876,18.6z"/>
+		<path fill="#FFFF3B" d="M10.898,18.6c0-7.245,5.86-13.166,13.166-13.166c7.245,0,13.167,5.86,13.167,13.166
+			c0,7.244-5.859,13.166-13.167,13.166C16.819,31.766,10.898,25.904,10.898,18.6z"/>
+		<path fill="#FFFF3C" d="M10.92,18.6c0-7.233,5.851-13.145,13.145-13.145c7.234,0,13.146,5.851,13.146,13.145
+			c0,7.233-5.854,13.145-13.146,13.145C16.831,31.745,10.92,25.895,10.92,18.6z"/>
+		<path fill="#FFFF3D" d="M10.941,18.6c0-7.222,5.842-13.125,13.124-13.125c7.222,0,13.125,5.842,13.125,13.125
+			c0,7.222-5.842,13.125-13.125,13.125C16.843,31.725,10.941,25.882,10.941,18.6z"/>
+		<path fill="#FFFF3E" d="M10.963,18.6c0-7.211,5.833-13.104,13.103-13.104c7.211,0,13.104,5.833,13.104,13.104
+			c0,7.21-5.832,13.103-13.104,13.103C16.855,31.703,10.963,25.87,10.963,18.6z"/>
+		<path fill="#FFFF3F" d="M10.984,18.6c0-7.2,5.823-13.082,13.083-13.082c7.201,0,13.083,5.823,13.083,13.082
+			c0,7.2-5.824,13.083-13.083,13.083C16.866,31.684,10.984,25.857,10.984,18.6z"/>
+		<path fill="#FFFF40" d="M11.005,18.6c0-7.189,5.815-13.062,13.062-13.062c7.189,0,13.062,5.814,13.062,13.062
+			c0,7.189-5.812,13.061-13.062,13.061C16.878,31.661,11.005,25.848,11.005,18.6z"/>
+		<path fill="#FFFF41" d="M11.027,18.6c0-7.178,5.805-13.041,13.041-13.041c7.178,0,13.042,5.805,13.042,13.041
+			c0,7.177-5.805,13.041-13.042,13.041C16.889,31.641,11.027,25.835,11.027,18.6z"/>
+		<path fill="#FFFF42" d="M11.048,18.6c0-7.167,5.796-13.02,13.02-13.02c7.167,0,13.02,5.796,13.02,13.02
+			c0,7.167-5.797,13.02-13.02,13.02C16.901,31.62,11.048,25.823,11.048,18.6z"/>
+		<path fill="#FFFF43" d="M11.07,18.6c0-7.156,5.787-12.999,12.998-12.999c7.157,0,13,5.787,13,12.999c0,7.155-5.787,13-13,13
+			C16.913,31.6,11.07,25.812,11.07,18.6z"/>
+		<path fill="#FFFF44" d="M11.091,18.6c0-7.145,5.778-12.978,12.978-12.978c7.146,0,12.978,5.778,12.978,12.978
+			c0,7.144-5.777,12.978-12.978,12.978C16.925,31.578,11.091,25.8,11.091,18.6z"/>
+		<path fill="#FFFF45" d="M11.113,18.6c0-7.133,5.769-12.957,12.957-12.957c7.133,0,12.958,5.769,12.958,12.957
+			c0,7.132-5.77,12.957-12.958,12.957C16.937,31.557,11.113,25.788,11.113,18.6z"/>
+		<path fill="#FFFF46" d="M11.135,18.6c0-7.123,5.759-12.936,12.936-12.936c7.123,0,12.937,5.759,12.937,12.936
+			c0,7.123-5.76,12.936-12.937,12.936C16.949,31.536,11.135,25.775,11.135,18.6z"/>
+		<path fill="#FFFF47" d="M11.157,18.6c0-7.111,5.75-12.915,12.915-12.915c7.112,0,12.915,5.75,12.915,12.915
+			c0,7.111-5.75,12.916-12.915,12.916C16.96,31.516,11.157,25.766,11.157,18.6z"/>
+		<path fill="#FFFF48" d="M11.178,18.6c0-7.1,5.741-12.894,12.895-12.894c7.101,0,12.894,5.741,12.894,12.894
+			c0,7.099-5.74,12.894-12.894,12.894C16.972,31.494,11.178,25.752,11.178,18.6z"/>
+		<path fill="#FFFF49" d="M11.199,18.6c0-7.089,5.732-12.873,12.874-12.873c7.089,0,12.873,5.731,12.873,12.873
+			c0,7.087-5.73,12.873-12.873,12.873C16.984,31.473,11.199,25.74,11.199,18.6z"/>
+		<path fill="#FFFF4A" d="M11.221,18.6c0-7.078,5.723-12.852,12.852-12.852c7.078,0,12.853,5.722,12.853,12.852
+			c0,7.078-5.725,12.852-12.854,12.852C16.995,31.452,11.221,25.729,11.221,18.6z"/>
+		<path fill="#FFFF4B" d="M11.242,18.6c0-7.067,5.714-12.832,12.832-12.832c7.067,0,12.833,5.713,12.833,12.832
+			c0,7.066-5.715,12.832-12.833,12.832C17.007,31.432,11.242,25.717,11.242,18.6z"/>
+		<path fill="#FFFF4C" d="M11.264,18.6c0-7.056,5.705-12.811,12.811-12.811c7.056,0,12.812,5.704,12.812,12.811
+			c0,7.054-5.705,12.81-12.812,12.81C17.019,31.41,11.264,25.705,11.264,18.6z"/>
+		<path fill="#FFFF4D" d="M11.286,18.6c0-7.044,5.695-12.79,12.79-12.79c7.045,0,12.79,5.695,12.79,12.79
+			c0,7.044-5.693,12.791-12.79,12.791C17.031,31.391,11.286,25.693,11.286,18.6z"/>
+		<path fill="#FFFF4E" d="M11.307,18.6c0-7.033,5.686-12.769,12.769-12.769c7.034,0,12.77,5.686,12.77,12.769
+			c0,7.034-5.688,12.768-12.77,12.768C17.043,31.368,11.307,25.684,11.307,18.6z"/>
+		<path fill="#FFFF4F" d="M11.329,18.6c0-7.022,5.677-12.748,12.748-12.748c7.023,0,12.748,5.677,12.748,12.748
+			c0,7.022-5.678,12.748-12.748,12.748C17.054,31.348,11.329,25.67,11.329,18.6z"/>
+		<path fill="#FFFF50" d="M11.351,18.6c0-7.011,5.667-12.727,12.727-12.727c7.012,0,12.727,5.668,12.727,12.727
+			c0,7.011-5.668,12.727-12.727,12.727C17.066,31.327,11.351,25.658,11.351,18.6z"/>
+		<path fill="#FFFF51" d="M11.372,18.6c0-7,5.659-12.706,12.706-12.706c7,0,12.705,5.659,12.705,12.706
+			c0,7-5.658,12.707-12.705,12.707C17.078,31.307,11.372,25.646,11.372,18.6z"/>
+		<path fill="#FFFF52" d="M11.394,18.6c0-6.989,5.65-12.685,12.685-12.685c6.987,0,12.685,5.65,12.685,12.685
+			c0,6.989-5.648,12.685-12.685,12.685C17.09,31.285,11.394,25.635,11.394,18.6z"/>
+		<path fill="#FFFF53" d="M11.415,18.6c0-6.978,5.641-12.664,12.664-12.664c6.978,0,12.665,5.641,12.665,12.664
+			c0,6.978-5.641,12.664-12.665,12.664C17.102,31.264,11.415,25.623,11.415,18.6z"/>
+		<path fill="#FFFF54" d="M11.437,18.6c0-6.967,5.631-12.643,12.643-12.643c6.967,0,12.645,5.631,12.645,12.643
+			c0,6.966-5.633,12.643-12.645,12.643C17.113,31.243,11.437,25.611,11.437,18.6z"/>
+		<path fill="#FFFF55" d="M11.459,18.6c0-6.956,5.622-12.623,12.622-12.623c6.956,0,12.622,5.623,12.622,12.623
+			c0,6.957-5.621,12.623-12.622,12.623C17.125,31.223,11.459,25.6,11.459,18.6z"/>
+		<path fill="#FFFF56" d="M11.48,18.6c0-6.944,5.613-12.602,12.602-12.602c6.945,0,12.602,5.613,12.602,12.602
+			c0,6.944-5.613,12.601-12.602,12.601C17.137,31.201,11.48,25.588,11.48,18.6z"/>
+		<path fill="#FFFF57" d="M11.502,18.6c0-6.934,5.604-12.581,12.581-12.581c6.933,0,12.581,5.604,12.581,12.581
+			c0,6.933-5.604,12.582-12.581,12.582C17.149,31.182,11.502,25.576,11.502,18.6z"/>
+		<path fill="#FFFF58" d="M11.523,18.6c0-6.922,5.595-12.56,12.56-12.56c6.923,0,12.56,5.595,12.56,12.56
+			c0,6.921-5.594,12.559-12.56,12.559C17.16,31.159,11.523,25.564,11.523,18.6z"/>
+		<path fill="#FFFF59" d="M11.545,18.6c0-6.911,5.585-12.539,12.539-12.539c6.912,0,12.539,5.585,12.539,12.539
+			c0,6.911-5.586,12.539-12.539,12.539C17.172,31.139,11.545,25.553,11.545,18.6z"/>
+		<path fill="#FFFF5A" d="M11.566,18.6c0-6.9,5.577-12.518,12.518-12.518c6.9,0,12.518,5.576,12.518,12.518
+			c0,6.9-5.576,12.517-12.518,12.517C17.184,31.117,11.566,25.541,11.566,18.6z"/>
+		<path fill="#FFFF5B" d="M11.588,18.6c0-6.889,5.567-12.497,12.497-12.497c6.89,0,12.497,5.567,12.497,12.497
+			c0,6.889-5.566,12.498-12.497,12.498C17.195,31.098,11.588,25.529,11.588,18.6z"/>
+		<path fill="#FFFF5C" d="M11.609,18.6c0-6.878,5.558-12.476,12.476-12.476c6.878,0,12.476,5.559,12.476,12.476
+			c0,6.876-5.559,12.476-12.476,12.476C17.208,31.076,11.609,25.518,11.609,18.6z"/>
+		<path fill="#FFFF5D" d="M11.631,18.6c0-6.867,5.549-12.455,12.455-12.455c6.867,0,12.455,5.549,12.455,12.455
+			c0,6.867-5.549,12.455-12.455,12.455C17.219,31.055,11.631,25.506,11.631,18.6z"/>
+		<path fill="#FFFF5E" d="M11.652,18.6c0-6.855,5.54-12.434,12.434-12.434c6.855,0,12.434,5.54,12.434,12.434
+			c0,6.855-5.539,12.434-12.434,12.434C17.231,31.034,11.652,25.494,11.652,18.6z"/>
+		<path fill="#FFFF5F" d="M11.674,18.6c0-6.844,5.531-12.413,12.413-12.413c6.845,0,12.415,5.531,12.415,12.413
+			c0,6.843-5.531,12.414-12.415,12.414C17.243,31.014,11.674,25.482,11.674,18.6z"/>
+		<path fill="#FFFF60" d="M11.695,18.6c0-6.833,5.521-12.392,12.393-12.392c6.834,0,12.393,5.521,12.393,12.392
+			c0,6.833-5.521,12.392-12.393,12.392C17.254,30.992,11.695,25.471,11.695,18.6z"/>
+		<path fill="#FFFF61" d="M11.717,18.6c0-6.822,5.513-12.371,12.372-12.371c6.823,0,12.372,5.512,12.372,12.371
+			c0,6.822-5.514,12.371-12.372,12.371C17.266,30.971,11.717,25.459,11.717,18.6z"/>
+		<path fill="#FFFF62" d="M11.739,18.6c0-6.811,5.503-12.351,12.35-12.351c6.812,0,12.351,5.503,12.351,12.351
+			c0,6.811-5.504,12.35-12.351,12.35C17.278,30.95,11.739,25.447,11.739,18.6z"/>
+		<path fill="#FFFF63" d="M11.76,18.6c0-6.8,5.494-12.33,12.33-12.33c6.799,0,12.33,5.494,12.33,12.33
+			c0,6.798-5.494,12.33-12.33,12.33C17.29,30.93,11.76,25.436,11.76,18.6z"/>
+		<path fill="#FFFF64" d="M11.782,18.6c0-6.789,5.485-12.309,12.309-12.309c6.79,0,12.31,5.485,12.31,12.309
+			c0,6.789-5.484,12.308-12.31,12.308C17.301,30.908,11.782,25.423,11.782,18.6z"/>
+		<path fill="#FFFF65" d="M11.803,18.6c0-6.778,5.476-12.288,12.288-12.288c6.778,0,12.288,5.476,12.288,12.288
+			c0,6.778-5.477,12.289-12.288,12.289C17.313,30.889,11.803,25.411,11.803,18.6z"/>
+		<path fill="#FFFF66" d="M11.825,18.6c0-6.767,5.467-12.267,12.267-12.267c6.768,0,12.268,5.466,12.268,12.267
+			c0,6.766-5.467,12.266-12.268,12.266C17.325,30.866,11.825,25.398,11.825,18.6z"/>
+		<path fill="#FFFF67" d="M11.847,18.6c0-6.756,5.457-12.246,12.246-12.246c6.757,0,12.247,5.458,12.247,12.246
+			c0,6.755-5.459,12.246-12.247,12.246C17.337,30.846,11.847,25.389,11.847,18.6z"/>
+		<path fill="#FFFF68" d="M11.868,18.6c0-6.745,5.449-12.225,12.225-12.225c6.745,0,12.226,5.448,12.226,12.225
+			c0,6.746-5.449,12.224-12.226,12.224C17.348,30.824,11.868,25.376,11.868,18.6z"/>
+		<path fill="#FFFF69" d="M11.89,18.6c0-6.733,5.439-12.204,12.204-12.204c6.732,0,12.205,5.439,12.205,12.204
+			c0,6.733-5.439,12.205-12.205,12.205C17.36,30.805,11.89,25.364,11.89,18.6z"/>
+		<path fill="#FFFF6A" d="M11.911,18.6c0-6.723,5.43-12.183,12.183-12.183c6.723,0,12.184,5.43,12.184,12.183
+			c0,6.722-5.43,12.183-12.184,12.183C17.372,30.783,11.911,25.354,11.911,18.6z"/>
+		<path fill="#FFFF6B" d="M11.933,18.6c0-6.711,5.421-12.162,12.162-12.162c6.712,0,12.163,5.421,12.163,12.162
+			c0,6.71-5.422,12.162-12.163,12.162C17.384,30.762,11.933,25.341,11.933,18.6z"/>
+		<path fill="#FFFF6C" d="M11.954,18.6c0-6.7,5.412-12.141,12.142-12.141c6.701,0,12.141,5.412,12.141,12.141
+			c0,6.7-5.412,12.141-12.141,12.141C17.396,30.741,11.954,25.329,11.954,18.6z"/>
+		<path fill="#FFFF6D" d="M11.976,18.6c0-6.689,5.402-12.121,12.12-12.121c6.688,0,12.121,5.403,12.121,12.121
+			c0,6.689-5.402,12.121-12.121,12.121C17.407,30.721,11.976,25.316,11.976,18.6z"/>
+		<path fill="#FFFF6E" d="M11.998,18.6c0-6.678,5.393-12.099,12.099-12.099c6.679,0,12.099,5.393,12.099,12.099
+			c0,6.677-5.393,12.099-12.099,12.099C17.419,30.699,11.998,25.307,11.998,18.6z"/>
+		<path fill="#FFFF6F" d="M12.019,18.6c0-6.667,5.384-12.079,12.079-12.079c6.667,0,12.078,5.384,12.078,12.079
+			c0,6.667-5.383,12.078-12.078,12.078C17.431,30.678,12.019,25.294,12.019,18.6z"/>
+		<path fill="#FFFF70" d="M12.041,18.6c0-6.656,5.375-12.058,12.058-12.058c6.655,0,12.057,5.375,12.057,12.058
+			c0,6.655-5.375,12.057-12.057,12.057C17.442,30.657,12.041,25.282,12.041,18.6z"/>
+		<path fill="#FFFF71" d="M12.062,18.6c0-6.645,5.366-12.037,12.037-12.037c6.645,0,12.036,5.366,12.036,12.037
+			c0,6.644-5.365,12.037-12.036,12.037C17.454,30.637,12.062,25.271,12.062,18.6z"/>
+		<path fill="#FFFF72" d="M12.084,18.6c0-6.633,5.357-12.016,12.016-12.016c6.632,0,12.015,5.357,12.015,12.016
+			c0,6.632-5.355,12.015-12.015,12.015C17.466,30.615,12.084,25.259,12.084,18.6z"/>
+		<path fill="#FFFF73" d="M12.105,18.6c0-6.622,5.348-11.995,11.995-11.995c6.623,0,11.996,5.348,11.996,11.995
+			c0,6.623-5.35,11.996-11.996,11.996C17.478,30.596,12.105,25.247,12.105,18.6z"/>
+		<path fill="#FFFF74" d="M12.127,18.6c0-6.611,5.338-11.974,11.974-11.974c6.612,0,11.973,5.339,11.973,11.974
+			c0,6.611-5.338,11.973-11.973,11.973C17.49,30.573,12.127,25.234,12.127,18.6z"/>
+		<path fill="#FFFF75" d="M12.149,18.6c0-6.6,5.329-11.953,11.953-11.953c6.599,0,11.953,5.33,11.953,11.953
+			c0,6.6-5.328,11.953-11.953,11.953C17.502,30.553,12.149,25.225,12.149,18.6z"/>
+		<path fill="#FFFF76" d="M12.17,18.6c0-6.589,5.32-11.932,11.932-11.932c6.589,0,11.931,5.32,11.931,11.932
+			c0,6.587-5.318,11.932-11.931,11.932C17.513,30.532,12.17,25.212,12.17,18.6z"/>
+		<path fill="#FFFF77" d="M12.192,18.6c0-6.578,5.311-11.911,11.911-11.911c6.579,0,11.913,5.311,11.913,11.911
+			c0,6.578-5.312,11.911-11.913,11.911C17.525,30.511,12.192,25.2,12.192,18.6z"/>
+		<path fill="#FFFF78" d="M12.213,18.6c0-6.567,5.302-11.89,11.891-11.89c6.568,0,11.89,5.302,11.89,11.89
+			c0,6.567-5.303,11.89-11.89,11.89C17.537,30.49,12.213,25.188,12.213,18.6z"/>
+		<path fill="#FFFF79" d="M12.235,18.6c0-6.556,5.292-11.87,11.869-11.87c6.556,0,11.869,5.293,11.869,11.87
+			c0,6.554-5.293,11.869-11.869,11.869C17.548,30.469,12.235,25.176,12.235,18.6z"/>
+		<path fill="#FFFF7A" d="M12.256,18.6c0-6.544,5.284-11.849,11.848-11.849c6.544,0,11.847,5.284,11.847,11.849
+			c0,6.544-5.281,11.848-11.847,11.848C17.56,30.448,12.256,25.164,12.256,18.6z"/>
+		<path fill="#FFFF7B" d="M12.278,18.6c0-6.533,5.274-11.828,11.828-11.828c6.533,0,11.828,5.274,11.828,11.828
+			c0,6.533-5.275,11.828-11.828,11.828C17.572,30.428,12.278,25.152,12.278,18.6z"/>
+		<path fill="#FFFF7C" d="M12.299,18.6c0-6.522,5.266-11.807,11.807-11.807c6.523,0,11.808,5.265,11.808,11.807
+			c0,6.522-5.268,11.806-11.808,11.806C17.584,30.406,12.299,25.141,12.299,18.6z"/>
+		<path fill="#FFFF7D" d="M12.321,18.6c0-6.511,5.256-11.786,11.786-11.786c6.51,0,11.786,5.256,11.786,11.786
+			c0,6.511-5.256,11.786-11.786,11.786C17.595,30.386,12.321,25.129,12.321,18.6z"/>
+		<path fill="#FFFF7E" d="M12.342,18.6c0-6.5,5.247-11.765,11.765-11.765c6.5,0,11.764,5.247,11.764,11.765
+			c0,6.5-5.246,11.764-11.764,11.764C17.608,30.364,12.342,25.117,12.342,18.6z"/>
+		<path fill="#FFFF7F" d="M12.364,18.6c0-6.489,5.238-11.744,11.744-11.744c6.49,0,11.744,5.238,11.744,11.744
+			c0,6.489-5.238,11.744-11.744,11.744C17.619,30.344,12.364,25.105,12.364,18.6z"/>
+		<path fill="#FFFF80" d="M12.386,18.6c0-6.478,5.229-11.723,11.723-11.723c6.479,0,11.723,5.229,11.723,11.723
+			c0,6.477-5.229,11.722-11.723,11.722C17.631,30.322,12.386,25.094,12.386,18.6z"/>
+		<path fill="#FFFF81" d="M12.407,18.6c0-6.467,5.22-11.702,11.702-11.702c6.465,0,11.702,5.22,11.702,11.702
+			c0,6.466-5.219,11.702-11.702,11.702C17.643,30.302,12.407,25.082,12.407,18.6z"/>
+		<path fill="#FFFF82" d="M12.429,18.6c0-6.456,5.21-11.681,11.681-11.681c6.455,0,11.681,5.21,11.681,11.681
+			c0,6.457-5.209,11.681-11.681,11.681C17.654,30.281,12.429,25.07,12.429,18.6z"/>
+		<path fill="#FFFF83" d="M12.45,18.6c0-6.444,5.202-11.66,11.661-11.66c6.444,0,11.661,5.201,11.661,11.66
+			c0,6.444-5.203,11.66-11.661,11.66C17.666,30.26,12.45,25.059,12.45,18.6z"/>
+		<path fill="#FFFF84" d="M12.472,18.6c0-6.434,5.192-11.639,11.639-11.639c6.434,0,11.639,5.192,11.639,11.639
+			c0,6.433-5.191,11.639-11.639,11.639C17.678,30.239,12.472,25.047,12.472,18.6z"/>
+		<path fill="#FFFF85" d="M12.493,18.6c0-6.422,5.183-11.619,11.619-11.619c6.421,0,11.619,5.183,11.619,11.619
+			c0,6.421-5.184,11.618-11.619,11.618C17.69,30.218,12.493,25.035,12.493,18.6z"/>
+		<path fill="#FFFF86" d="M12.515,18.6c0-6.411,5.174-11.598,11.598-11.598c6.411,0,11.598,5.174,11.598,11.598
+			c0,6.411-5.174,11.597-11.598,11.597C17.701,30.197,12.515,25.023,12.515,18.6z"/>
+		<path fill="#FFFF87" d="M12.537,18.6c0-6.4,5.165-11.577,11.577-11.577c6.4,0,11.578,5.165,11.578,11.577
+			c0,6.4-5.166,11.577-11.578,11.577C17.713,30.177,12.537,25.012,12.537,18.6z"/>
+		<path fill="#FFFF88" d="M12.558,18.6c0-6.389,5.156-11.556,11.556-11.556c6.39,0,11.556,5.155,11.556,11.556
+			c0,6.388-5.156,11.554-11.556,11.554C17.725,30.154,12.558,25,12.558,18.6z"/>
+		<path fill="#FFFF89" d="M12.58,18.6c0-6.378,5.146-11.535,11.535-11.535c6.377,0,11.534,5.146,11.534,11.535
+			c0,6.376-5.145,11.535-11.534,11.535C17.737,30.135,12.58,24.988,12.58,18.6z"/>
+		<path fill="#FFFF8A" d="M12.601,18.6c0-6.367,5.138-11.514,11.514-11.514c6.368,0,11.514,5.137,11.514,11.514
+			c0,6.367-5.139,11.513-11.514,11.513C17.749,30.113,12.601,24.977,12.601,18.6z"/>
+		<path fill="#FFFF8B" d="M12.623,18.6c0-6.356,5.128-11.493,11.493-11.493c6.355,0,11.494,5.128,11.494,11.493
+			c0,6.355-5.129,11.493-11.494,11.493C17.76,30.093,12.623,24.965,12.623,18.6z"/>
+		<path fill="#FFFF8C" d="M12.645,18.6c0-6.345,5.119-11.472,11.472-11.472c6.344,0,11.473,5.119,11.473,11.472
+			c0,6.343-5.119,11.47-11.473,11.47C17.772,30.07,12.645,24.953,12.645,18.6z"/>
+		<path fill="#FFFF8D" d="M12.666,18.6c0-6.333,5.11-11.451,11.451-11.451c6.333,0,11.452,5.11,11.452,11.451
+			c0,6.333-5.109,11.451-11.452,11.451C17.784,30.051,12.666,24.941,12.666,18.6z"/>
+		<path fill="#FFFF8E" d="M12.688,18.6c0-6.322,5.101-11.43,11.43-11.43c6.322,0,11.431,5.101,11.431,11.43
+			c0,6.322-5.102,11.429-11.431,11.429C17.796,30.029,12.688,24.93,12.688,18.6z"/>
+		<path fill="#FFFF8F" d="M12.709,18.6c0-6.312,5.092-11.409,11.41-11.409c6.311,0,11.409,5.091,11.409,11.409
+			c0,6.311-5.092,11.409-11.409,11.409C17.807,30.009,12.709,24.917,12.709,18.6z"/>
+		<path fill="#FFFF90" d="M12.731,18.6c0-6.3,5.083-11.388,11.389-11.388c6.3,0,11.388,5.082,11.388,11.388
+			c0,6.298-5.082,11.388-11.388,11.388C17.819,29.988,12.731,24.904,12.731,18.6z"/>
+		<path fill="#FFFF91" d="M12.753,18.6c0-6.289,5.073-11.368,11.367-11.368c6.288,0,11.366,5.073,11.366,11.368
+			c0,6.289-5.072,11.367-11.366,11.367C17.831,29.967,12.753,24.895,12.753,18.6z"/>
+		<path fill="#FFFF92" d="M12.774,18.6c0-6.278,5.064-11.347,11.347-11.347c6.277,0,11.346,5.064,11.346,11.347
+			c0,6.278-5.062,11.345-11.346,11.345C17.842,29.945,12.774,24.882,12.774,18.6z"/>
+		<path fill="#FFFF93" d="M12.796,18.6c0-6.267,5.055-11.326,11.326-11.326c6.267,0,11.325,5.055,11.325,11.326
+			c0,6.266-5.055,11.326-11.325,11.326C17.854,29.926,12.796,24.87,12.796,18.6z"/>
+		<path fill="#FFFF94" d="M12.817,18.6c0-6.256,5.046-11.305,11.305-11.305c6.257,0,11.306,5.046,11.306,11.305
+			c0,6.255-5.047,11.304-11.306,11.304C17.866,29.904,12.817,24.857,12.817,18.6z"/>
+		<path fill="#FFFF95" d="M12.838,18.6c0-6.245,5.037-11.284,11.284-11.284c6.243,0,11.282,5.037,11.282,11.284
+			c0,6.246-5.035,11.284-11.282,11.284C17.878,29.884,12.838,24.848,12.838,18.6z"/>
+		<path fill="#FFFF96" d="M12.86,18.6c0-6.233,5.028-11.263,11.263-11.263c6.232,0,11.262,5.028,11.262,11.263
+			c0,6.233-5.027,11.261-11.262,11.261C17.89,29.861,12.86,24.835,12.86,18.6z"/>
+		<path fill="#FFFF97" d="M12.882,18.6c0-6.223,5.018-11.242,11.242-11.242c6.222,0,11.241,5.019,11.241,11.242
+			c0,6.222-5.018,11.242-11.241,11.242C17.901,29.842,12.882,24.823,12.882,18.6z"/>
+		<path fill="#FFFF98" d="M12.903,18.6c0-6.211,5.009-11.221,11.221-11.221S35.346,12.388,35.346,18.6
+			c0,6.21-5.01,11.22-11.222,11.22C17.913,29.82,12.903,24.812,12.903,18.6z"/>
+		<path fill="#FFFF99" d="M12.925,18.6c0-6.2,5-11.2,11.2-11.2c6.199,0,11.199,5,11.199,11.2c0,6.2-5,11.2-11.199,11.2
+			C17.925,29.8,12.925,24.8,12.925,18.6z"/>
+	</g>
+	
+		<linearGradient id="XMLID_67_" gradientUnits="userSpaceOnUse" x1="396.2324" y1="753.8262" x2="396.2324" y2="763.584" gradientTransform="matrix(1 0 0 1 -372 -747)">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="1" style="stop-color:#FFFF99"/>
+	</linearGradient>
+	<path fill="url(#XMLID_67_)" d="M15.358,11.705c0-2.701,3.961-4.879,8.875-4.879c4.912,0,8.875,2.178,8.875,4.879
+		s-3.963,4.879-8.875,4.879C19.32,16.583,15.358,14.405,15.358,11.705z"/>
+	<path fill="#666666" d="M23.125,41.3v0.9c0,0.899,0.7,1.6,1.6,1.6c0.9,0,1.6-0.7,1.6-1.6v-0.9h-3.299H23.125z"/>
+	
+		<linearGradient id="XMLID_68_" gradientUnits="userSpaceOnUse" x1="396.625" y1="784.8896" x2="396.625" y2="788.9111" gradientTransform="matrix(1 0 0 1 -372 -747)">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="1" style="stop-color:#000000"/>
+	</linearGradient>
+	<path fill="url(#XMLID_68_)" d="M28.225,37.9l-7.6,0.8c-0.9,0.1-1.5,0.899-1.4,1.8c0.1,0.9,0.9,1.5,1.8,1.4l7.6-0.801
+		c0.9-0.102,1.5-0.899,1.4-1.802C29.926,38.4,29.125,37.8,28.225,37.9z"/>
+	
+		<linearGradient id="XMLID_69_" gradientUnits="userSpaceOnUse" x1="396.625" y1="781.6895" x2="396.625" y2="785.7109" gradientTransform="matrix(1 0 0 1 -372 -747)">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="1" style="stop-color:#000000"/>
+	</linearGradient>
+	<path fill="url(#XMLID_69_)" d="M28.225,34.7l-7.6,0.8c-0.9,0.1-1.5,0.9-1.4,1.8c0.1,0.9,0.9,1.5,1.8,1.4l7.6-0.8
+		c0.9-0.101,1.5-0.9,1.4-1.801C29.926,35.2,29.125,34.6,28.225,34.7z"/>
+	
+		<linearGradient id="XMLID_70_" gradientUnits="userSpaceOnUse" x1="396.625" y1="778.5889" x2="396.625" y2="782.6104" gradientTransform="matrix(1 0 0 1 -372 -747)">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="1" style="stop-color:#000000"/>
+	</linearGradient>
+	<path fill="url(#XMLID_70_)" d="M28.225,31.6l-7.6,0.801c-0.9,0.1-1.5,0.897-1.4,1.8c0.1,0.899,0.9,1.5,1.8,1.399l7.6-0.802
+		c0.9-0.1,1.5-0.897,1.4-1.8S29.125,31.5,28.225,31.6z"/>
+	<path fill="none" stroke="#000000" stroke-width="1.0944" d="M22.325,28.3l-3.5-10.7c0,0,6.601,3.9,10.5,0"/>
+</g>
+<g id="crop_x0020_marks">
+	<path fill="none" d="M47.975,48h-48V0h48V48z"/>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/up.svg b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/up.svg
new file mode 100644
index 0000000..8eca45f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/up.svg
@@ -0,0 +1,338 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.1" id="Up" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="48" height="48" viewBox="0 0 48 48"
+	 overflow="visible" enable-background="new 0 0 48 48" xml:space="preserve">
+<g>
+	<path fill="#FFFFFF" stroke="#FFFFFF" stroke-width="7.5901" stroke-linejoin="round" d="M41.104,25.661
+		c0.301,0,0.301-0.3,0.198-0.5l-16.899-16.6c-0.5-0.5-0.7-0.4-1,0l-16.7,16.6c-0.1,0.103-0.1,0.399,0.1,0.399h10v13.601
+		c0,0.301,0.2,0.5,0.4,0.5h13.299c0.398,0,0.5-0.199,0.5-0.601v-13.5L41.104,25.661z"/>
+	<g>
+		<path fill="#0033CC" d="M41.104,25.661c0.301,0,0.301-0.3,0.198-0.5l-16.899-16.6c-0.5-0.5-0.7-0.4-1,0l-16.7,16.6
+			c-0.1,0.103-0.1,0.399,0.1,0.399h10v13.601c0,0.301,0.2,0.5,0.4,0.5h13.299c0.398,0,0.5-0.199,0.5-0.601v-13.5L41.104,25.661z"/>
+		<path fill="#0134CC" d="M41.075,25.65c0.3,0,0.3-0.299,0.198-0.498L24.402,8.577c-0.499-0.499-0.699-0.4-0.998,0L6.73,25.152
+			c-0.1,0.101-0.1,0.397,0.099,0.397h9.984v13.581c0,0.303,0.2,0.499,0.4,0.499h13.279c0.398,0,0.499-0.196,0.499-0.601V25.55
+			L41.075,25.65z"/>
+		<path fill="#0235CD" d="M41.049,25.643c0.301,0,0.301-0.3,0.199-0.498L24.401,8.591c-0.498-0.498-0.697-0.399-0.996,0
+			L6.757,25.145c-0.1,0.101-0.1,0.397,0.099,0.397h9.969v13.562c0,0.301,0.199,0.5,0.399,0.5H30.48c0.397,0,0.498-0.199,0.498-0.601
+			V25.542L41.049,25.643z"/>
+		<path fill="#0336CD" d="M41.021,25.632c0.299,0,0.299-0.299,0.199-0.498L24.4,8.604c-0.498-0.498-0.696-0.399-0.995,0
+			L6.783,25.134c-0.099,0.101-0.099,0.398,0.099,0.398h9.953v13.543c0,0.299,0.199,0.495,0.398,0.495h13.24
+			c0.396,0,0.495-0.196,0.495-0.596v-13.44L41.021,25.632z"/>
+		<path fill="#0437CE" d="M40.995,25.622c0.299,0,0.299-0.299,0.198-0.496L24.4,8.62c-0.497-0.497-0.696-0.398-0.994,0L6.811,25.126
+			c-0.099,0.101-0.099,0.396,0.099,0.396h9.938v13.523c0,0.299,0.199,0.496,0.397,0.496h13.217c0.396,0,0.496-0.197,0.496-0.598
+			v-13.42L40.995,25.622z"/>
+		<path fill="#0538CE" d="M40.969,25.614c0.299,0,0.299-0.3,0.198-0.498L24.399,8.634c-0.496-0.496-0.694-0.397-0.992,0
+			L6.837,25.116c-0.099,0.102-0.099,0.397,0.099,0.397h9.922v13.504c0,0.299,0.199,0.496,0.398,0.496h13.195
+			c0.396,0,0.494-0.197,0.494-0.597V25.514L40.969,25.614z"/>
+		<path fill="#0639CF" d="M40.941,25.604c0.297,0,0.297-0.297,0.197-0.496L24.399,8.649c-0.496-0.496-0.693-0.397-0.99,0
+			L6.864,25.107c-0.099,0.101-0.099,0.396,0.099,0.396h9.906v13.483c0,0.3,0.199,0.496,0.397,0.496h13.173
+			c0.396,0,0.496-0.196,0.496-0.596V25.505L40.941,25.604z"/>
+		<path fill="#073ACF" d="M40.915,25.594c0.298,0,0.298-0.298,0.196-0.494L24.398,8.664c-0.495-0.495-0.692-0.397-0.989,0
+			L6.891,25.1c-0.099,0.101-0.099,0.396,0.098,0.396h9.892V38.96c0,0.298,0.198,0.494,0.396,0.494h13.155
+			c0.396,0,0.494-0.196,0.494-0.593V25.495L40.915,25.594z"/>
+		<path fill="#083BD0" d="M40.891,25.585c0.297,0,0.297-0.297,0.196-0.496l-16.69-16.41c-0.494-0.494-0.691-0.396-0.987,0
+			L6.918,25.089c-0.099,0.101-0.099,0.396,0.098,0.396h9.875V38.93c0,0.299,0.198,0.495,0.396,0.495h13.134
+			c0.396,0,0.494-0.196,0.494-0.595V25.486L40.891,25.585z"/>
+		<path fill="#093CD0" d="M40.859,25.575c0.3,0,0.3-0.296,0.199-0.494L24.397,8.692c-0.493-0.494-0.69-0.396-0.985,0L6.945,25.081
+			c-0.098,0.101-0.098,0.396,0.098,0.396h9.86v13.428c0,0.298,0.197,0.494,0.395,0.494h13.113c0.396,0,0.491-0.196,0.491-0.594
+			V25.477L40.859,25.575z"/>
+		<path fill="#0A3DD1" d="M40.835,25.564c0.296,0,0.296-0.295,0.197-0.491L24.396,8.707c-0.492-0.493-0.689-0.395-0.984,0
+			L6.972,25.073c-0.098,0.098-0.098,0.395,0.098,0.395h9.844v13.408c0,0.295,0.197,0.492,0.394,0.492h13.09
+			c0.396,0,0.492-0.197,0.492-0.593V25.465L40.835,25.564z"/>
+		<path fill="#0B3ED1" d="M40.811,25.557c0.295,0,0.295-0.296,0.195-0.492L24.396,8.723c-0.492-0.493-0.688-0.394-0.983,0
+			L6.999,25.062c-0.098,0.101-0.098,0.396,0.098,0.396h9.829v13.388c0,0.297,0.197,0.491,0.394,0.491h13.073
+			c0.395,0,0.489-0.194,0.489-0.59V25.458L40.811,25.557z"/>
+		<path fill="#0C3FD2" d="M40.782,25.546c0.295,0,0.295-0.295,0.194-0.491L24.395,8.736c-0.491-0.492-0.687-0.394-0.981,0
+			L7.026,25.055c-0.098,0.1-0.098,0.396,0.098,0.396h9.813v13.368c0,0.296,0.197,0.49,0.393,0.49h13.051
+			c0.395,0,0.49-0.194,0.49-0.588V25.448L40.782,25.546z"/>
+		<path fill="#0D40D2" d="M40.755,25.536c0.295,0,0.295-0.293,0.196-0.49L24.394,8.75c-0.489-0.491-0.685-0.393-0.979,0
+			L7.053,25.046c-0.098,0.099-0.098,0.394,0.098,0.394h9.797V38.79c0,0.297,0.196,0.492,0.392,0.492h13.03
+			c0.394,0,0.489-0.195,0.489-0.591V25.438L40.755,25.536z"/>
+		<path fill="#0E41D3" d="M40.729,25.527c0.293,0,0.293-0.295,0.195-0.489L24.394,8.766c-0.489-0.489-0.685-0.392-0.978,0
+			L7.08,25.038c-0.097,0.099-0.097,0.394,0.098,0.394h9.782V38.76c0,0.295,0.196,0.489,0.392,0.489h13.007
+			c0.394,0,0.488-0.194,0.488-0.588V25.43L40.729,25.527z"/>
+		<path fill="#0F42D3" d="M40.702,25.518c0.294,0,0.294-0.293,0.194-0.488L24.393,8.781c-0.488-0.489-0.683-0.392-0.976,0
+			L7.107,25.027c-0.097,0.101-0.097,0.394,0.098,0.394h9.766v13.312c0,0.295,0.195,0.49,0.391,0.49h12.99
+			c0.393,0,0.487-0.195,0.487-0.588V25.419L40.702,25.518z"/>
+		<path fill="#1043D4" d="M40.676,25.508c0.293,0,0.293-0.294,0.195-0.488L24.392,8.794c-0.487-0.488-0.682-0.392-0.975,0
+			L7.134,25.02c-0.097,0.101-0.097,0.394,0.097,0.394h9.75v13.293c0,0.293,0.196,0.485,0.391,0.485H30.34
+			c0.393,0,0.487-0.192,0.487-0.586V25.411L40.676,25.508z"/>
+		<path fill="#1144D4" d="M40.646,25.497c0.293,0,0.293-0.293,0.194-0.487l-16.45-16.2c-0.487-0.488-0.681-0.391-0.973,0L7.16,25.01
+			C7.063,25.107,7.063,25.4,7.257,25.4h9.735v13.271c0,0.294,0.195,0.487,0.39,0.487H30.33c0.389,0,0.484-0.193,0.484-0.586V25.4
+			L40.646,25.497z"/>
+		<path fill="#1245D5" d="M40.622,25.489c0.293,0,0.293-0.294,0.194-0.488L24.391,8.824c-0.486-0.487-0.68-0.39-0.972,0
+			L7.188,25.001c-0.097,0.099-0.097,0.392,0.096,0.392h9.72v13.254c0,0.293,0.195,0.486,0.389,0.486h12.925
+			c0.391,0,0.486-0.193,0.486-0.585V25.393L40.622,25.489z"/>
+		<path fill="#1346D5" d="M40.598,25.479c0.291,0,0.291-0.291,0.192-0.484L24.391,8.838c-0.485-0.486-0.679-0.39-0.97,0
+			L7.215,24.993c-0.097,0.099-0.097,0.39,0.096,0.39h9.704v13.235c0,0.291,0.195,0.485,0.389,0.485h12.907
+			c0.391,0,0.484-0.194,0.484-0.584V25.382L40.598,25.479z"/>
+		<path fill="#1447D6" d="M40.568,25.471c0.291,0,0.291-0.293,0.193-0.486L24.39,8.853c-0.484-0.485-0.678-0.389-0.968,0
+			L7.242,24.982c-0.097,0.1-0.097,0.391,0.096,0.391h9.688v13.215c0,0.293,0.194,0.486,0.388,0.486H30.3
+			c0.39,0,0.484-0.193,0.484-0.582v-13.12L40.568,25.471z"/>
+		<path fill="#1548D6" d="M40.542,25.46c0.291,0,0.291-0.291,0.192-0.485L24.389,8.868c-0.483-0.485-0.677-0.388-0.966,0
+			L7.269,24.975c-0.097,0.101-0.097,0.392,0.096,0.392h9.673v13.194c0,0.291,0.193,0.483,0.387,0.483h12.864
+			c0.387,0,0.482-0.192,0.482-0.582V25.361L40.542,25.46z"/>
+		<path fill="#1649D7" d="M40.518,25.45c0.291,0,0.291-0.291,0.191-0.483L24.389,8.881c-0.483-0.484-0.676-0.388-0.966,0
+			L7.295,24.966c-0.096,0.099-0.096,0.388,0.096,0.388h9.657v13.181c0,0.291,0.193,0.481,0.387,0.481h12.842
+			c0.388,0,0.48-0.19,0.48-0.582v-13.08L40.518,25.45z"/>
+		<path fill="#174AD7" d="M40.488,25.441c0.289,0,0.289-0.291,0.193-0.483L24.388,8.896c-0.482-0.483-0.675-0.388-0.964,0
+			L7.323,24.956c-0.096,0.099-0.096,0.39,0.096,0.39h9.642v13.155c0,0.291,0.193,0.483,0.386,0.483h12.825
+			c0.386,0,0.479-0.192,0.479-0.58V25.346L40.488,25.441z"/>
+		<path fill="#184BD8" d="M40.463,25.432c0.289,0,0.289-0.289,0.191-0.481L24.387,8.912c-0.481-0.482-0.673-0.387-0.962,0
+			L7.349,24.948c-0.096,0.098-0.096,0.387,0.096,0.387h9.626v13.14c0,0.291,0.193,0.483,0.386,0.483h12.802
+			c0.388,0,0.479-0.192,0.479-0.58V25.335L40.463,25.432z"/>
+		<path fill="#194CD8" d="M40.438,25.421c0.289,0,0.289-0.289,0.19-0.481L24.386,8.926c-0.48-0.481-0.672-0.386-0.96,0L7.376,24.938
+			c-0.096,0.1-0.096,0.389,0.096,0.389h9.61v13.117c0,0.291,0.192,0.482,0.385,0.482h12.782c0.385,0,0.479-0.191,0.479-0.578V25.325
+			L40.438,25.421z"/>
+		<path fill="#1A4DD9" d="M40.409,25.413c0.289,0,0.289-0.289,0.19-0.481L24.386,8.939c-0.48-0.481-0.671-0.385-0.959,0
+			L7.403,24.932c-0.096,0.096-0.096,0.385,0.096,0.385h9.595v13.103c0,0.289,0.192,0.479,0.384,0.479h12.76
+			c0.385,0,0.479-0.19,0.479-0.578V25.316L40.409,25.413z"/>
+		<path fill="#1B4ED9" d="M40.383,25.402c0.288,0,0.288-0.288,0.191-0.479L24.386,8.956c-0.479-0.481-0.67-0.385-0.958,0
+			L7.43,24.921c-0.095,0.099-0.095,0.386,0.096,0.386h9.579v13.082c0,0.288,0.192,0.479,0.384,0.479H30.23
+			c0.383,0,0.479-0.191,0.479-0.576V25.307L40.383,25.402z"/>
+		<path fill="#1C4FDA" d="M40.355,25.395c0.287,0,0.287-0.289,0.188-0.479L24.385,8.97c-0.479-0.48-0.669-0.384-0.956,0
+			L7.457,24.913c-0.096,0.097-0.096,0.385,0.095,0.385h9.563v13.062c0,0.289,0.192,0.479,0.383,0.479h12.72
+			c0.384,0,0.479-0.19,0.479-0.575V25.296L40.355,25.395z"/>
+		<path fill="#1D50DA" d="M40.329,25.383c0.287,0,0.287-0.287,0.19-0.479L24.384,8.983c-0.478-0.479-0.668-0.384-0.955,0
+			L7.484,24.902c-0.095,0.099-0.095,0.386,0.095,0.386h9.548v13.043c0,0.287,0.191,0.479,0.382,0.479h12.699
+			c0.383,0,0.478-0.191,0.478-0.576V25.288L40.329,25.383z"/>
+		<path fill="#1E51DB" d="M40.303,25.374c0.286,0,0.286-0.287,0.19-0.479L24.384,8.999c-0.477-0.479-0.667-0.383-0.953,0
+			L7.511,24.895c-0.095,0.099-0.095,0.385,0.094,0.385h9.533v13.022c0,0.287,0.191,0.479,0.382,0.479h12.678
+			c0.382,0,0.477-0.189,0.477-0.574v-12.93L40.303,25.374z"/>
+		<path fill="#1F52DB" d="M40.275,25.364c0.285,0,0.285-0.287,0.188-0.479L24.383,9.014c-0.476-0.478-0.666-0.383-0.951,0
+			L7.539,24.886c-0.095,0.097-0.095,0.384,0.094,0.384h9.517v13.004c0,0.287,0.191,0.479,0.381,0.479h12.658
+			c0.381,0,0.476-0.19,0.476-0.573V25.27L40.275,25.364z"/>
+		<path fill="#2053DC" d="M40.25,25.354c0.285,0,0.285-0.285,0.188-0.479L24.382,9.027c-0.475-0.477-0.665-0.382-0.95,0
+			L7.565,24.876c-0.095,0.097-0.095,0.383,0.094,0.383h9.501v12.984c0,0.286,0.19,0.479,0.381,0.479h12.637
+			c0.381,0,0.477-0.189,0.477-0.572V25.259L40.25,25.354z"/>
+		<path fill="#2154DC" d="M40.225,25.346c0.283,0,0.283-0.287,0.188-0.478L24.381,9.042c-0.474-0.476-0.664-0.381-0.948,0
+			L7.591,24.868c-0.094,0.096-0.094,0.383,0.095,0.383h9.486v12.965c0,0.287,0.19,0.478,0.38,0.478h12.616
+			c0.38,0,0.475-0.188,0.475-0.569V25.249L40.225,25.346z"/>
+		<path fill="#2255DD" d="M40.195,25.335c0.285,0,0.285-0.285,0.188-0.478L24.38,9.057c-0.474-0.475-0.663-0.381-0.947,0
+			L7.619,24.859c-0.094,0.097-0.094,0.382,0.094,0.382h9.471v12.946c0,0.285,0.189,0.476,0.379,0.476h12.596
+			c0.378,0,0.473-0.188,0.473-0.57V25.241L40.195,25.335z"/>
+		<path fill="#2356DD" d="M40.17,25.327c0.284,0,0.284-0.285,0.188-0.478L24.381,9.072c-0.473-0.475-0.662-0.38-0.945,0
+			l-15.79,15.78c-0.094,0.097-0.094,0.381,0.094,0.381h9.455V38.16c0,0.285,0.189,0.476,0.379,0.476h12.574
+			c0.377,0,0.473-0.188,0.473-0.569V25.23L40.17,25.327z"/>
+		<path fill="#2457DE" d="M40.145,25.316c0.282,0,0.282-0.284,0.188-0.478L24.38,9.085c-0.472-0.474-0.661-0.38-0.944,0
+			L7.673,24.841c-0.095,0.097-0.095,0.382,0.094,0.382h9.439V38.13c0,0.285,0.189,0.476,0.378,0.476h12.555
+			c0.379,0,0.473-0.188,0.473-0.569V25.223L40.145,25.316z"/>
+		<path fill="#2558DE" d="M40.116,25.307c0.282,0,0.282-0.285,0.188-0.476L24.379,9.101c-0.472-0.474-0.66-0.379-0.942,0
+			L7.699,24.831c-0.094,0.097-0.094,0.381,0.094,0.381h9.424v12.89c0,0.284,0.189,0.476,0.377,0.476h12.533
+			c0.378,0,0.473-0.188,0.473-0.568V25.212L40.116,25.307z"/>
+		<path fill="#2659DF" d="M40.09,25.298c0.283,0,0.283-0.284,0.188-0.475L24.379,9.116c-0.471-0.473-0.659-0.379-0.94,0
+			L7.727,24.823c-0.094,0.096-0.094,0.381,0.094,0.381h9.408v12.869c0,0.282,0.189,0.473,0.377,0.473h12.512
+			c0.376,0,0.47-0.188,0.47-0.567V25.204L40.09,25.298z"/>
+		<path fill="#275ADF" d="M40.062,25.288c0.28,0,0.28-0.283,0.188-0.474L24.378,9.13c-0.47-0.472-0.657-0.378-0.938,0L7.754,24.814
+			c-0.094,0.097-0.094,0.379,0.093,0.379h9.393v12.851c0,0.285,0.188,0.474,0.376,0.474h12.489c0.377,0,0.472-0.188,0.472-0.565
+			V25.193L40.062,25.288z"/>
+		<path fill="#285BE0" d="M40.037,25.277c0.279,0,0.279-0.282,0.188-0.471L24.377,9.145c-0.469-0.471-0.656-0.378-0.937,0
+			L7.781,24.807c-0.094,0.096-0.094,0.377,0.093,0.377h9.377v12.832c0,0.283,0.188,0.474,0.376,0.474H30.1
+			c0.375,0,0.467-0.188,0.467-0.566V25.184L40.037,25.277z"/>
+		<path fill="#295CE0" d="M40.01,25.27c0.281,0,0.281-0.283,0.188-0.474L24.376,9.159c-0.468-0.47-0.655-0.377-0.936,0L7.807,24.796
+			c-0.093,0.097-0.093,0.378,0.093,0.378h9.361v12.812c0,0.281,0.188,0.471,0.375,0.471h12.45c0.374,0,0.467-0.188,0.467-0.562
+			V25.174L40.01,25.27z"/>
+		<path fill="#2A5DE1" d="M39.982,25.259c0.281,0,0.281-0.282,0.188-0.471L24.376,9.174c-0.467-0.469-0.654-0.376-0.934,0
+			L7.834,24.788c-0.093,0.096-0.093,0.377,0.093,0.377h9.346v12.793c0,0.283,0.188,0.472,0.375,0.472h12.43
+			c0.373,0,0.467-0.188,0.467-0.563v-12.7L39.982,25.259z"/>
+		<path fill="#2B5EE1" d="M39.957,25.249c0.279,0,0.279-0.281,0.188-0.472L24.376,9.188c-0.466-0.469-0.652-0.376-0.933,0
+			L7.861,24.779c-0.093,0.095-0.093,0.375,0.093,0.375h9.33V37.93c0,0.282,0.188,0.471,0.374,0.471h12.408
+			c0.373,0,0.467-0.188,0.467-0.563v-12.68L39.957,25.249z"/>
+		<path fill="#2C5FE2" d="M39.932,25.239c0.278,0,0.278-0.281,0.188-0.47L24.375,9.203c-0.465-0.468-0.652-0.375-0.931,0
+			L7.888,24.771c-0.093,0.096-0.093,0.375,0.092,0.375h9.314V37.9c0,0.281,0.187,0.47,0.374,0.47h12.389
+			c0.373,0,0.465-0.188,0.465-0.562V25.146L39.932,25.239z"/>
+		<path fill="#2D60E2" d="M39.902,25.229c0.279,0,0.279-0.277,0.187-0.468L24.374,9.217c-0.465-0.467-0.651-0.375-0.929,0
+			L7.915,24.762c-0.093,0.094-0.093,0.374,0.092,0.374h9.299V37.87c0,0.28,0.187,0.469,0.373,0.469h12.368
+			c0.371,0,0.465-0.188,0.465-0.562V25.136L39.902,25.229z"/>
+		<path fill="#2E61E3" d="M39.877,25.221c0.277,0,0.277-0.279,0.188-0.468L24.374,9.231c-0.464-0.466-0.649-0.374-0.928,0
+			L7.942,24.753c-0.092,0.095-0.092,0.373,0.092,0.373h9.284v12.717c0,0.281,0.186,0.47,0.372,0.47h12.347
+			c0.372,0,0.464-0.188,0.464-0.562V25.126L39.877,25.221z"/>
+		<path fill="#2F62E3" d="M39.852,25.212c0.277,0,0.277-0.28,0.188-0.469L24.373,9.248c-0.463-0.466-0.648-0.374-0.926,0
+			L7.969,24.745c-0.092,0.094-0.092,0.373,0.092,0.373h9.268v12.696c0,0.278,0.186,0.468,0.371,0.468h12.325
+			c0.371,0,0.463-0.188,0.463-0.562V25.118L39.852,25.212z"/>
+		<path fill="#3063E4" d="M39.823,25.202c0.276,0,0.276-0.279,0.186-0.468L24.372,9.262c-0.462-0.465-0.647-0.373-0.925,0
+			L7.996,24.734c-0.092,0.095-0.092,0.373,0.092,0.373h9.252v12.679c0,0.278,0.186,0.467,0.371,0.467h12.307
+			c0.369,0,0.461-0.188,0.461-0.562V25.107L39.823,25.202z"/>
+		<path fill="#3164E4" d="M39.797,25.191c0.277,0,0.277-0.278,0.186-0.467L24.373,9.274c-0.462-0.465-0.646-0.373-0.923,0
+			L8.023,24.727C7.931,24.82,7.931,25.1,8.115,25.1h9.236v12.657c0,0.279,0.186,0.466,0.371,0.466h12.284
+			c0.369,0,0.461-0.187,0.461-0.56V25.1L39.797,25.191z"/>
+		<path fill="#3265E5" d="M39.771,25.184c0.275,0,0.275-0.279,0.186-0.467L24.371,9.29c-0.461-0.464-0.645-0.372-0.922,0
+			L8.05,24.717c-0.092,0.094-0.092,0.372,0.091,0.372h9.221v12.64c0,0.279,0.185,0.465,0.37,0.465h12.264
+			c0.367,0,0.46-0.186,0.46-0.558V25.089L39.771,25.184z"/>
+		<path fill="#3366E5" d="M39.744,25.173c0.275,0,0.275-0.278,0.186-0.465L24.371,9.306c-0.46-0.463-0.644-0.372-0.92,0
+			L8.077,24.708c-0.092,0.094-0.092,0.371,0.091,0.371h9.206V37.7c0,0.276,0.185,0.463,0.369,0.463h12.241
+			c0.369,0,0.461-0.187,0.461-0.558V25.081L39.744,25.173z"/>
+		<path fill="#3366E6" d="M39.717,25.163c0.276,0,0.276-0.277,0.186-0.463L24.37,9.319c-0.459-0.462-0.643-0.371-0.918,0L8.104,24.7
+			c-0.092,0.094-0.092,0.37,0.091,0.37h9.189v12.601c0,0.279,0.185,0.465,0.369,0.465h12.224c0.366,0,0.459-0.186,0.459-0.557V25.07
+			L39.717,25.163z"/>
+		<path fill="#3467E6" d="M39.689,25.152c0.273,0,0.273-0.276,0.185-0.463L24.369,9.333c-0.458-0.462-0.642-0.371-0.917,0
+			L8.131,24.689c-0.092,0.095-0.092,0.371,0.091,0.371h9.174v12.582c0,0.274,0.184,0.463,0.368,0.463h12.202
+			c0.366,0,0.458-0.188,0.458-0.558V25.061L39.689,25.152z"/>
+		<path fill="#3568E7" d="M39.664,25.145c0.273,0,0.273-0.276,0.186-0.463L24.369,9.349c-0.458-0.461-0.641-0.37-0.916,0
+			L8.158,24.682c-0.091,0.094-0.091,0.37,0.091,0.37h9.159v12.562c0,0.276,0.184,0.461,0.367,0.461h12.181
+			c0.367,0,0.458-0.185,0.458-0.556V25.05L39.664,25.145z"/>
+		<path fill="#3669E7" d="M39.639,25.135c0.273,0,0.273-0.277,0.185-0.462L24.368,9.364c-0.458-0.46-0.64-0.37-0.914,0l-15.27,15.31
+			c-0.091,0.094-0.091,0.368,0.091,0.368h9.144v12.543c0,0.276,0.183,0.463,0.366,0.463h12.158c0.365,0,0.457-0.187,0.457-0.555
+			V25.042L39.639,25.135z"/>
+		<path fill="#376AE8" d="M39.609,25.124c0.272,0,0.272-0.274,0.184-0.461L24.367,9.377c-0.457-0.459-0.639-0.369-0.912,0
+			L8.211,24.663c-0.091,0.094-0.091,0.369,0.091,0.369h9.127v12.522c0,0.274,0.184,0.461,0.366,0.461h12.141
+			c0.363,0,0.455-0.187,0.455-0.554v-12.43L39.609,25.124z"/>
+		<path fill="#386BE8" d="M39.584,25.116c0.271,0,0.271-0.277,0.184-0.462L24.368,9.393c-0.456-0.459-0.638-0.368-0.911,0
+			L8.239,24.654c-0.091,0.093-0.091,0.369,0.09,0.369h9.112v12.504c0,0.274,0.183,0.462,0.365,0.462h12.12
+			c0.363,0,0.454-0.188,0.454-0.554V25.023L39.584,25.116z"/>
+		<path fill="#396CE9" d="M39.559,25.105c0.272,0,0.272-0.274,0.183-0.459L24.366,9.407c-0.455-0.458-0.636-0.367-0.909,0
+			L8.266,24.646c-0.091,0.093-0.091,0.367,0.09,0.367h9.096v12.483c0,0.272,0.183,0.459,0.365,0.459h12.098
+			c0.362,0,0.454-0.187,0.454-0.552V25.014L39.559,25.105z"/>
+		<path fill="#3A6DE9" d="M39.529,25.096c0.271,0,0.271-0.275,0.184-0.457L24.365,9.421c-0.454-0.458-0.635-0.367-0.907,0
+			L8.293,24.639c-0.091,0.092-0.091,0.364,0.09,0.364h9.081v12.468c0,0.274,0.182,0.459,0.364,0.459h12.076
+			c0.363,0,0.453-0.185,0.453-0.552V25.003L39.529,25.096z"/>
+		<path fill="#3B6EEA" d="M39.504,25.087c0.271,0,0.271-0.274,0.184-0.459L24.365,9.436c-0.454-0.457-0.634-0.366-0.906,0
+			L8.319,24.628c-0.09,0.093-0.09,0.367,0.09,0.367h9.065v12.446c0,0.272,0.182,0.457,0.363,0.457h12.06
+			c0.359,0,0.451-0.185,0.451-0.549V24.995L39.504,25.087z"/>
+		<path fill="#3C6FEA" d="M39.479,25.077c0.271,0,0.271-0.272,0.183-0.457L24.364,9.451c-0.453-0.456-0.633-0.366-0.905,0
+			L8.346,24.62c-0.09,0.092-0.09,0.364,0.09,0.364h9.05v12.429c0,0.274,0.182,0.457,0.363,0.457h12.036
+			c0.361,0,0.451-0.183,0.451-0.55V24.984L39.479,25.077z"/>
+		<path fill="#3D70EB" d="M39.451,25.066c0.271,0,0.271-0.272,0.181-0.457L24.363,9.464c-0.452-0.455-0.632-0.365-0.903,0
+			L8.374,24.609c-0.09,0.093-0.09,0.367,0.089,0.367h9.034v12.406c0,0.271,0.181,0.456,0.362,0.456h12.016
+			c0.359,0,0.45-0.185,0.45-0.549V24.977L39.451,25.066z"/>
+		<path fill="#3E71EB" d="M39.424,25.059c0.271,0,0.271-0.272,0.182-0.457L24.363,9.479c-0.451-0.455-0.631-0.365-0.901,0
+			L8.4,24.602c-0.09,0.092-0.09,0.365,0.09,0.365h9.019v12.389c0,0.272,0.181,0.457,0.362,0.457h11.992
+			c0.361,0,0.451-0.185,0.451-0.547V24.967L39.424,25.059z"/>
+		<path fill="#3F72EC" d="M39.396,25.048c0.271,0,0.271-0.272,0.182-0.455L24.362,9.495c-0.45-0.454-0.63-0.364-0.9,0L8.427,24.593
+			c-0.09,0.093-0.09,0.363,0.089,0.363h9.003v12.371c0,0.272,0.181,0.455,0.361,0.455h11.976c0.357,0,0.447-0.183,0.447-0.548
+			V24.956L39.396,25.048z"/>
+		<path fill="#4073EC" d="M39.371,25.038c0.271,0,0.271-0.272,0.18-0.455L24.362,9.509c-0.45-0.453-0.629-0.363-0.898,0
+			L8.454,24.583c-0.09,0.093-0.09,0.362,0.089,0.362h8.987v12.354c0,0.271,0.181,0.454,0.36,0.454h11.954
+			c0.358,0,0.448-0.183,0.448-0.545v-12.26L39.371,25.038z"/>
+		<path fill="#4174ED" d="M39.346,25.029c0.271,0,0.271-0.271,0.18-0.454L24.361,9.523c-0.449-0.453-0.627-0.363-0.897,0
+			L8.481,24.575c-0.089,0.092-0.089,0.362,0.089,0.362h8.972V37.27c0,0.272,0.18,0.455,0.359,0.455h11.933
+			c0.357,0,0.445-0.183,0.445-0.545V24.938L39.346,25.029z"/>
+		<path fill="#4275ED" d="M39.316,25.02c0.271,0,0.271-0.271,0.181-0.453L24.36,9.539c-0.448-0.452-0.626-0.362-0.895,0
+			L8.508,24.566c-0.09,0.091-0.09,0.36,0.088,0.36h8.957V37.24c0,0.271,0.18,0.451,0.359,0.451h11.912
+			c0.355,0,0.445-0.183,0.445-0.543V24.93L39.316,25.02z"/>
+		<path fill="#4376EE" d="M39.291,25.01c0.27,0,0.27-0.271,0.18-0.453L24.36,9.553c-0.447-0.451-0.625-0.361-0.894,0L8.535,24.559
+			c-0.089,0.09-0.089,0.362,0.089,0.362h8.941v12.293c0,0.271,0.179,0.451,0.358,0.451h11.892c0.356,0,0.445-0.181,0.445-0.543
+			V24.919L39.291,25.01z"/>
+		<path fill="#4477EE" d="M39.266,24.999c0.27,0,0.27-0.271,0.18-0.451L24.359,9.566c-0.446-0.45-0.625-0.361-0.893,0L8.562,24.549
+			c-0.089,0.09-0.089,0.362,0.088,0.362h8.925v12.272c0,0.271,0.179,0.45,0.358,0.45h11.87c0.356,0,0.445-0.182,0.445-0.542V24.911
+			L39.266,24.999z"/>
+		<path fill="#4578EF" d="M39.236,24.991c0.27,0,0.27-0.271,0.18-0.451L24.359,9.582c-0.446-0.45-0.624-0.36-0.891,0L8.589,24.54
+			C8.5,24.63,8.5,24.9,8.677,24.9h8.91v12.254c0,0.271,0.179,0.451,0.357,0.451h11.85c0.354,0,0.442-0.182,0.442-0.541V24.9
+			L39.236,24.991z"/>
+		<path fill="#4679EF" d="M39.211,24.98c0.27,0,0.27-0.271,0.18-0.449L24.358,9.597c-0.445-0.449-0.622-0.36-0.889,0L8.616,24.531
+			c-0.089,0.089-0.089,0.359,0.088,0.359h8.894v12.233c0,0.271,0.179,0.451,0.356,0.451h11.83c0.354,0,0.442-0.183,0.442-0.541
+			V24.891L39.211,24.98z"/>
+		<path fill="#477AF0" d="M39.186,24.973c0.269,0,0.269-0.271,0.178-0.451L24.357,9.61c-0.444-0.448-0.621-0.359-0.888,0
+			L8.643,24.521c-0.088,0.09-0.088,0.358,0.088,0.358h8.878v12.218c0,0.271,0.179,0.448,0.356,0.448h11.809
+			c0.354,0,0.441-0.182,0.441-0.54V24.882L39.186,24.973z"/>
+		<path fill="#487BF0" d="M39.158,24.962c0.267,0,0.267-0.271,0.178-0.448L24.356,9.625c-0.443-0.447-0.62-0.359-0.886,0
+			L8.669,24.514c-0.088,0.09-0.088,0.358,0.088,0.358h8.863v12.196c0,0.271,0.178,0.449,0.355,0.449h11.789
+			c0.354,0,0.44-0.181,0.44-0.539V24.872L39.158,24.962z"/>
+		<path fill="#497CF1" d="M39.132,24.952c0.267,0,0.267-0.269,0.179-0.447L24.356,9.64c-0.442-0.446-0.619-0.358-0.884,0
+			L8.697,24.504c-0.088,0.09-0.088,0.357,0.087,0.357h8.847V37.04c0,0.271,0.178,0.449,0.355,0.449h11.768
+			c0.354,0,0.439-0.181,0.439-0.539V24.861L39.132,24.952z"/>
+		<path fill="#4A7DF1" d="M39.104,24.943c0.269,0,0.269-0.271,0.18-0.448L24.355,9.655c-0.442-0.446-0.618-0.358-0.883,0
+			L8.724,24.496c-0.088,0.089-0.088,0.357,0.087,0.357h8.832v12.16c0,0.268,0.177,0.445,0.354,0.445h11.747
+			c0.354,0,0.439-0.182,0.439-0.537V24.854L39.104,24.943z"/>
+		<path fill="#4B7EF2" d="M39.078,24.934c0.265,0,0.265-0.269,0.177-0.447L24.355,9.67c-0.441-0.445-0.617-0.357-0.881,0
+			L8.751,24.486c-0.088,0.091-0.088,0.357,0.087,0.357h8.816v12.14c0,0.27,0.177,0.447,0.354,0.447h11.727
+			c0.354,0,0.438-0.18,0.438-0.535V24.844L39.078,24.934z"/>
+		<path fill="#4C7FF2" d="M39.052,24.924c0.265,0,0.265-0.27,0.177-0.446L24.354,9.684c-0.44-0.444-0.616-0.356-0.879,0
+			L8.777,24.478c-0.088,0.09-0.088,0.355,0.087,0.355h8.8v12.121c0,0.269,0.177,0.444,0.353,0.444h11.706
+			c0.354,0,0.438-0.178,0.438-0.534V24.833L39.052,24.924z"/>
+		<path fill="#4D80F3" d="M39.023,24.913c0.266,0,0.266-0.269,0.178-0.444L24.354,9.699c-0.439-0.444-0.615-0.356-0.878,0
+			L8.804,24.469c-0.087,0.09-0.087,0.356,0.087,0.356h8.785v12.101c0,0.268,0.177,0.444,0.353,0.444h11.684
+			c0.352,0,0.438-0.179,0.438-0.533V24.825L39.023,24.913z"/>
+		<path fill="#4E81F3" d="M38.998,24.904c0.266,0,0.266-0.269,0.176-0.445L24.353,9.712c-0.439-0.443-0.614-0.355-0.877,0
+			L8.832,24.459c-0.088,0.089-0.088,0.355,0.086,0.355h8.77v12.082c0,0.269,0.176,0.443,0.352,0.443h11.664
+			c0.351,0,0.438-0.179,0.438-0.531V24.814L38.998,24.904z"/>
+		<path fill="#4F82F4" d="M38.973,24.896c0.264,0,0.264-0.27,0.176-0.445L24.353,9.728c-0.438-0.442-0.613-0.355-0.875,0
+			L8.858,24.451c-0.087,0.089-0.087,0.355,0.087,0.355h8.754V36.87c0,0.266,0.176,0.442,0.351,0.442h11.644
+			c0.352,0,0.438-0.18,0.438-0.533V24.807L38.973,24.896z"/>
+		<path fill="#5083F4" d="M38.943,24.886c0.264,0,0.264-0.268,0.177-0.444l-14.769-14.7c-0.437-0.441-0.611-0.354-0.874,0
+			l-14.593,14.7c-0.087,0.09-0.087,0.354,0.086,0.354h8.738v12.043c0,0.267,0.176,0.443,0.351,0.443h11.623
+			c0.351,0,0.438-0.179,0.438-0.531V24.796L38.943,24.886z"/>
+		<path fill="#5184F5" d="M38.919,24.876c0.263,0,0.263-0.267,0.174-0.443L24.351,9.756c-0.437-0.441-0.61-0.354-0.872,0
+			L8.912,24.434c-0.087,0.089-0.087,0.354,0.086,0.354h8.723v12.022c0,0.267,0.175,0.44,0.35,0.44h11.602
+			c0.349,0,0.437-0.178,0.437-0.528V24.788L38.919,24.876z"/>
+		<path fill="#5285F5" d="M38.893,24.866c0.262,0,0.262-0.267,0.176-0.441L24.351,9.771c-0.436-0.44-0.609-0.353-0.871,0
+			L8.939,24.425c-0.087,0.089-0.087,0.353,0.086,0.353h8.707v12.009c0,0.265,0.175,0.438,0.349,0.438h11.581
+			c0.348,0,0.436-0.177,0.436-0.529V24.777L38.893,24.866z"/>
+		<path fill="#5386F6" d="M38.863,24.855c0.263,0,0.263-0.266,0.176-0.44L24.35,9.786c-0.435-0.439-0.608-0.353-0.869,0
+			L8.966,24.415C8.88,24.504,8.88,24.77,9.052,24.77h8.691v11.983c0,0.267,0.175,0.44,0.349,0.44h11.561
+			c0.349,0,0.435-0.176,0.435-0.528V24.77L38.863,24.855z"/>
+		<path fill="#5487F6" d="M38.839,24.848c0.261,0,0.261-0.267,0.175-0.439L24.349,9.801c-0.434-0.439-0.607-0.352-0.867,0
+			L8.993,24.407c-0.087,0.089-0.087,0.353,0.086,0.353h8.676v11.967c0,0.267,0.174,0.44,0.348,0.44h11.54
+			c0.349,0,0.435-0.178,0.435-0.528v-11.88L38.839,24.848z"/>
+		<path fill="#5588F7" d="M38.812,24.837c0.262,0,0.262-0.264,0.174-0.439L24.349,9.814c-0.433-0.438-0.606-0.352-0.866,0
+			L9.02,24.397c-0.086,0.088-0.086,0.352,0.086,0.352h8.66v11.949c0,0.262,0.174,0.438,0.347,0.438h11.519
+			c0.347,0,0.433-0.177,0.433-0.528V24.749L38.812,24.837z"/>
+		<path fill="#5689F7" d="M38.785,24.829c0.26,0,0.26-0.265,0.173-0.439L24.348,9.83c-0.432-0.438-0.604-0.351-0.864,0L9.047,24.389
+			c-0.086,0.088-0.086,0.353,0.085,0.353h8.645V36.67c0,0.264,0.174,0.438,0.347,0.438h11.498c0.345,0,0.431-0.176,0.431-0.524
+			v-11.84L38.785,24.829z"/>
+		<path fill="#578AF8" d="M38.759,24.818c0.261,0,0.261-0.264,0.175-0.438L24.347,9.844c-0.432-0.437-0.604-0.35-0.863,0
+			L9.074,24.379c-0.086,0.088-0.086,0.352,0.085,0.352h8.629v11.91c0,0.262,0.173,0.438,0.346,0.438h11.476
+			c0.348,0,0.434-0.177,0.434-0.524V24.73L38.759,24.818z"/>
+		<path fill="#588BF8" d="M38.73,24.809c0.258,0,0.258-0.263,0.172-0.438L24.347,9.858c-0.431-0.436-0.603-0.35-0.861,0
+			L9.101,24.372c-0.086,0.088-0.086,0.351,0.085,0.351H17.8v11.892c0,0.262,0.173,0.438,0.345,0.438h11.458
+			c0.344,0,0.428-0.177,0.428-0.524V24.721L38.73,24.809z"/>
+		<path fill="#598CF9" d="M38.705,24.799c0.259,0,0.259-0.262,0.173-0.438L24.346,9.873c-0.43-0.435-0.602-0.349-0.86,0
+			L9.128,24.361c-0.086,0.088-0.086,0.351,0.085,0.351h8.598v11.869c0,0.263,0.173,0.438,0.345,0.438h11.436
+			c0.344,0,0.43-0.178,0.43-0.524V24.712L38.705,24.799z"/>
+		<path fill="#5A8DF9" d="M38.68,24.79c0.258,0,0.258-0.265,0.172-0.438L24.345,9.888c-0.429-0.435-0.6-0.349-0.858,0L9.155,24.353
+			c-0.086,0.088-0.086,0.35,0.085,0.35h8.583v11.852c0,0.262,0.172,0.438,0.344,0.438h11.414c0.343,0,0.428-0.177,0.428-0.524
+			V24.702L38.68,24.79z"/>
+		<path fill="#5B8EFA" d="M38.65,24.779c0.259,0,0.259-0.262,0.173-0.437L24.345,9.902c-0.428-0.434-0.599-0.348-0.856,0
+			L9.182,24.345c-0.085,0.087-0.085,0.348,0.085,0.348h8.567v11.832c0,0.262,0.172,0.438,0.343,0.438h11.396
+			c0.342,0,0.427-0.176,0.427-0.523V24.691L38.65,24.779z"/>
+		<path fill="#5C8FFA" d="M38.626,24.771c0.256,0,0.256-0.263,0.171-0.437L24.344,9.917c-0.428-0.433-0.599-0.348-0.855,0
+			L9.209,24.335c-0.085,0.087-0.085,0.349,0.084,0.349h8.552v11.812c0,0.262,0.172,0.438,0.343,0.438h11.375
+			c0.342,0,0.426-0.176,0.426-0.521V24.684L38.626,24.771z"/>
+		<path fill="#5D90FB" d="M38.6,24.761c0.258,0,0.258-0.261,0.172-0.434L24.344,9.932c-0.427-0.432-0.598-0.347-0.854,0
+			L9.235,24.327c-0.085,0.087-0.085,0.347,0.084,0.347h8.536v11.794c0,0.261,0.172,0.435,0.343,0.435h11.353
+			c0.342,0,0.428-0.174,0.428-0.521V24.674L38.6,24.761z"/>
+		<path fill="#5E91FB" d="M38.57,24.751c0.258,0,0.258-0.26,0.173-0.434l-14.4-14.372c-0.426-0.432-0.596-0.346-0.852,0
+			L9.263,24.317c-0.085,0.087-0.085,0.346,0.084,0.346h8.52v11.776c0,0.259,0.171,0.433,0.342,0.433h11.332
+			c0.34,0,0.424-0.174,0.424-0.521V24.663L38.57,24.751z"/>
+		<path fill="#5F92FC" d="M38.546,24.743c0.255,0,0.255-0.262,0.17-0.435L24.342,9.96c-0.425-0.431-0.595-0.346-0.85,0L9.29,24.309
+			c-0.085,0.087-0.085,0.347,0.084,0.347h8.504v11.756c0,0.258,0.171,0.434,0.341,0.434h11.311c0.342,0,0.426-0.176,0.426-0.521
+			V24.654L38.546,24.743z"/>
+		<path fill="#6093FC" d="M38.521,24.732c0.254,0,0.254-0.26,0.17-0.435L24.342,9.976c-0.425-0.43-0.594-0.345-0.849,0L9.316,24.3
+			c-0.085,0.087-0.085,0.347,0.084,0.347h8.489v11.735c0,0.259,0.171,0.433,0.341,0.433h11.292c0.34,0,0.424-0.174,0.424-0.521
+			V24.646L38.521,24.732z"/>
+		<path fill="#6194FD" d="M38.492,24.723c0.255,0,0.255-0.259,0.17-0.432L24.341,9.99c-0.424-0.43-0.593-0.345-0.847,0L9.343,24.291
+			c-0.084,0.086-0.084,0.345,0.084,0.345H17.9v11.718c0,0.258,0.17,0.433,0.34,0.433h11.27c0.34,0,0.424-0.175,0.424-0.519V24.636
+			L38.492,24.723z"/>
+		<path fill="#6295FD" d="M38.466,24.712c0.255,0,0.255-0.258,0.169-0.43L24.34,10.004c-0.423-0.429-0.592-0.344-0.846,0
+			L9.37,24.283c-0.084,0.086-0.084,0.345,0.084,0.345h8.458v11.697c0,0.258,0.17,0.43,0.339,0.43H29.5
+			c0.338,0,0.422-0.172,0.422-0.516V24.626L38.466,24.712z"/>
+		<path fill="#6396FE" d="M38.438,24.704c0.254,0,0.254-0.259,0.17-0.431L24.34,10.019c-0.422-0.428-0.591-0.343-0.844,0
+			L9.397,24.273c-0.084,0.086-0.084,0.345,0.083,0.345h8.442v11.678c0,0.259,0.17,0.431,0.339,0.431H29.49
+			c0.338,0,0.422-0.172,0.422-0.517V24.618L38.438,24.704z"/>
+		<path fill="#6497FE" d="M38.413,24.693c0.252,0,0.252-0.257,0.168-0.429l-14.242-14.23c-0.422-0.427-0.59-0.343-0.843,0
+			L9.424,24.265c-0.084,0.086-0.084,0.342,0.083,0.342h8.427v11.66c0,0.258,0.169,0.43,0.338,0.43H29.48
+			c0.336,0,0.42-0.172,0.42-0.516V24.607L38.413,24.693z"/>
+		<path fill="#6598FF" d="M38.387,24.686c0.254,0,0.254-0.259,0.17-0.43L24.338,10.047c-0.42-0.426-0.588-0.342-0.841,0
+			L9.451,24.255c-0.084,0.086-0.084,0.343,0.083,0.343h8.411V36.24c0,0.256,0.169,0.428,0.337,0.428h11.187
+			c0.338,0,0.42-0.172,0.42-0.516V24.6L38.387,24.686z"/>
+		<path fill="#6699FF" d="M38.357,24.675c0.252,0,0.252-0.257,0.168-0.428L24.338,10.062c-0.42-0.426-0.587-0.342-0.839,0
+			L9.478,24.247c-0.084,0.086-0.084,0.342,0.083,0.342h8.396V36.21c0,0.256,0.169,0.429,0.337,0.429h11.167
+			c0.335,0,0.418-0.173,0.418-0.515V24.589L38.357,24.675z"/>
+	</g>
+	
+		<linearGradient id="XMLID_20_" gradientUnits="userSpaceOnUse" x1="-1371.771" y1="-727.9985" x2="-1398.6362" y2="-727.9985" gradientTransform="matrix(4.371139e-08 -1 -1 -4.371139e-08 -703.999 -1361.9985)">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="1" style="stop-color:#6699FF"/>
+	</linearGradient>
+	<path fill="url(#XMLID_20_)" d="M38.357,24.675c0.252,0,0.252-0.257,0.168-0.428L24.338,10.062c-0.42-0.426-0.587-0.342-0.839,0
+		L9.478,24.247c-0.084,0.086-0.084,0.342,0.083,0.342h8.396V36.21c0,0.256,0.169,0.429,0.337,0.429h11.167
+		c0.335,0,0.418-0.173,0.418-0.515V24.589L38.357,24.675z"/>
+</g>
+<g id="crop_x0020_marks">
+	<path fill="none" d="M48-0.058v48H0v-48H48z"/>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/warning.svg b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/warning.svg
new file mode 100644
index 0000000..ae0081d
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/colorsvg/warning.svg
@@ -0,0 +1,232 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Generator: Adobe Illustrator 12.0.1, SVG Export Plug-In . SVG Version: 6.00 Build 51448)  -->
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
+	<!ENTITY ns_svg "http://www.w3.org/2000/svg">
+	<!ENTITY ns_xlink "http://www.w3.org/1999/xlink">
+]>
+<svg  version="1.1" id="Layer_1" xmlns="&ns_svg;" xmlns:xlink="&ns_xlink;" width="48" height="48" viewBox="0 0 48 48"
+	 overflow="visible" enable-background="new 0 0 48 48" xml:space="preserve">
+<g>
+	<path stroke="#FFFFFF" stroke-width="7.9139" stroke-linejoin="round" d="M16.4,42.3L5.7,31.6V16.4L16.4,5.7h15.2l10.7,10.7v15.2
+		L31.6,42.3H16.4z"/>
+	<g>
+		<path fill="#990000" d="M16.4,42.3L5.7,31.6V16.4L16.4,5.7h15.2l10.7,10.7v15.2L31.6,42.3H16.4z"/>
+		<polygon fill="#9A0000" points="16.415,42.266 5.736,31.586 5.736,16.416 16.415,5.737 31.585,5.737 42.266,16.416 42.266,31.586 
+			31.585,42.266 		"/>
+		<polygon fill="#9B0000" points="16.429,42.23 5.771,31.572 5.771,16.432 16.429,5.774 31.57,5.774 42.229,16.432 42.229,31.572 
+			31.57,42.23 		"/>
+		<polygon fill="#9C0000" points="16.444,42.195 5.806,31.559 5.806,16.447 16.444,5.81 31.557,5.81 42.191,16.447 42.191,31.559 
+			31.557,42.195 		"/>
+		<polygon fill="#9D0000" points="16.459,42.162 5.842,31.545 5.842,16.464 16.459,5.847 31.54,5.847 42.157,16.464 42.157,31.545 
+			31.54,42.162 		"/>
+		<polygon fill="#9E0000" points="16.473,42.128 5.877,31.531 5.877,16.479 16.473,5.884 31.525,5.884 42.122,16.479 42.122,31.531 
+			31.525,42.128 		"/>
+		<polygon fill="#9F0000" points="16.488,42.094 5.914,31.52 5.914,16.496 16.488,5.921 31.512,5.921 42.087,16.496 42.087,31.52 
+			31.512,42.094 		"/>
+		<polygon fill="#A00000" points="16.503,42.061 5.949,31.505 5.949,16.511 16.503,5.958 31.496,5.958 42.051,16.511 42.051,31.505 
+			31.496,42.061 		"/>
+		<polygon fill="#A10000" points="16.518,42.025 5.984,31.491 5.984,16.528 16.518,5.994 31.48,5.994 42.016,16.528 42.016,31.491 
+			31.48,42.025 		"/>
+		<polygon fill="#A20000" points="16.533,41.991 6.02,31.479 6.02,16.544 16.533,6.031 31.467,6.031 41.98,16.544 41.98,31.479 
+			31.467,41.991 		"/>
+		<polygon fill="#A30000" points="16.547,41.956 6.055,31.464 6.055,16.56 16.547,6.067 31.452,6.067 41.943,16.56 41.943,31.464 
+			31.452,41.956 		"/>
+		<polygon fill="#A40000" points="16.562,41.923 6.091,31.451 6.091,16.576 16.562,6.104 31.438,6.104 41.909,16.576 41.909,31.451 
+			31.438,41.923 		"/>
+		<polygon fill="#A50000" points="16.577,41.889 6.126,31.438 6.126,16.592 16.577,6.141 31.423,6.141 41.873,16.592 41.873,31.438 
+			31.423,41.889 		"/>
+		<polygon fill="#A60000" points="16.592,41.854 6.162,31.424 6.162,16.607 16.592,6.177 31.407,6.177 41.838,16.607 41.838,31.424 
+			31.407,41.854 		"/>
+		<polygon fill="#A70000" points="16.606,41.818 6.197,31.41 6.197,16.624 16.606,6.214 31.395,6.214 41.803,16.624 41.803,31.41 
+			31.395,41.818 		"/>
+		<polygon fill="#A80000" points="16.622,41.785 6.233,31.396 6.233,16.64 16.622,6.251 31.379,6.251 41.768,16.64 41.768,31.396 
+			31.379,41.785 		"/>
+		<polygon fill="#A90000" points="16.636,41.751 6.269,31.383 6.269,16.655 16.636,6.288 31.363,6.288 41.73,16.655 41.73,31.383 
+			31.363,41.751 		"/>
+		<polygon fill="#AA0000" points="16.65,41.716 6.304,31.369 6.304,16.671 16.65,6.325 31.35,6.325 41.695,16.671 41.695,31.369 
+			31.35,41.716 		"/>
+		<polygon fill="#AB0000" points="16.666,41.682 6.339,31.355 6.339,16.688 16.666,6.361 31.334,6.361 41.66,16.688 41.66,31.355 
+			31.334,41.682 		"/>
+		<polygon fill="#AC0000" points="16.681,41.648 6.375,31.343 6.375,16.704 16.681,6.398 31.318,6.398 41.625,16.704 41.625,31.343 
+			31.318,41.648 		"/>
+		<polygon fill="#AD0000" points="16.695,41.613 6.411,31.329 6.411,16.719 16.695,6.435 31.305,6.435 41.589,16.719 41.589,31.329 
+			31.305,41.613 		"/>
+		<polygon fill="#AE0000" points="16.709,41.579 6.446,31.314 6.446,16.735 16.709,6.472 31.29,6.472 41.555,16.735 41.555,31.314 
+			31.29,41.579 		"/>
+		<polygon fill="#AF0000" points="16.725,41.545 6.482,31.302 6.482,16.751 16.725,6.509 31.273,6.509 41.52,16.751 41.52,31.302 
+			31.273,41.545 		"/>
+		<polygon fill="#B00000" points="16.739,41.511 6.518,31.288 6.518,16.767 16.739,6.545 31.262,6.545 41.482,16.767 41.482,31.288 
+			31.262,41.511 		"/>
+		<polygon fill="#B10000" points="16.754,41.477 6.553,31.273 6.553,16.783 16.754,6.582 31.245,6.582 41.447,16.783 41.447,31.273 
+			31.245,41.477 		"/>
+		<polygon fill="#B20000" points="16.769,41.441 6.588,31.261 6.588,16.799 16.769,6.619 31.23,6.619 41.411,16.799 41.411,31.261 
+			31.23,41.441 		"/>
+		<polygon fill="#B30000" points="16.783,41.407 6.624,31.248 6.624,16.815 16.783,6.656 31.216,6.656 41.376,16.815 41.376,31.248 
+			31.216,41.407 		"/>
+		<polygon fill="#B40000" points="16.799,41.373 6.66,31.234 6.66,16.832 16.799,6.693 31.202,6.693 41.341,16.832 41.341,31.234 
+			31.202,41.373 		"/>
+		<polygon fill="#B50000" points="16.813,41.339 6.695,31.221 6.695,16.847 16.813,6.729 31.188,6.729 41.305,16.847 41.305,31.221 
+			31.188,41.339 		"/>
+		<polygon fill="#B60000" points="16.828,41.305 6.73,31.207 6.73,16.863 16.828,6.765 31.172,6.765 41.27,16.863 41.27,31.207 
+			31.172,41.305 		"/>
+		<polygon fill="#B70000" points="16.843,41.27 6.766,31.193 6.766,16.879 16.843,6.802 31.157,6.802 41.232,16.879 41.232,31.193 
+			31.157,41.27 		"/>
+		<polygon fill="#B80000" points="16.858,41.236 6.802,31.182 6.802,16.896 16.858,6.839 31.143,6.839 41.198,16.896 41.198,31.182 
+			31.143,41.236 		"/>
+		<polygon fill="#B90000" points="16.872,41.202 6.837,31.166 6.837,16.911 16.872,6.876 31.128,6.876 41.163,16.911 41.163,31.166 
+			31.128,41.202 		"/>
+		<polygon fill="#BA0000" points="16.887,41.167 6.873,31.152 6.873,16.927 16.887,6.913 31.111,6.913 41.127,16.927 41.127,31.152 
+			31.111,41.167 		"/>
+		<polygon fill="#BB0000" points="16.902,41.133 6.908,31.139 6.908,16.943 16.902,6.949 31.098,6.949 41.092,16.943 41.092,31.139 
+			31.098,41.133 		"/>
+		<polygon fill="#BC0000" points="16.917,41.1 6.944,31.126 6.944,16.959 16.917,6.986 31.083,6.986 41.057,16.959 41.057,31.126 
+			31.083,41.1 		"/>
+		<polygon fill="#BD0000" points="16.931,41.064 6.979,31.111 6.979,16.975 16.931,7.023 31.068,7.023 41.021,16.975 41.021,31.111 
+			31.068,41.064 		"/>
+		<polygon fill="#BE0000" points="16.946,41.029 7.015,31.1 7.015,16.991 16.946,7.06 31.055,7.06 40.984,16.991 40.984,31.1 
+			31.055,41.029 		"/>
+		<polygon fill="#BF0000" points="16.96,40.995 7.051,31.085 7.051,17.007 16.96,7.097 31.039,7.097 40.949,17.007 40.949,31.085 
+			31.039,40.995 		"/>
+		<polygon fill="#C00000" points="16.976,40.962 7.086,31.072 7.086,17.023 16.976,7.133 31.023,7.133 40.914,17.023 40.914,31.072 
+			31.023,40.962 		"/>
+		<polygon fill="#C10000" points="16.99,40.927 7.121,31.059 7.121,17.039 16.99,7.17 31.01,7.17 40.878,17.039 40.878,31.059 
+			31.01,40.927 		"/>
+		<polygon fill="#C20000" points="17.004,40.893 7.157,31.044 7.157,17.054 17.004,7.207 30.994,7.207 40.843,17.054 40.843,31.044 
+			30.994,40.893 		"/>
+		<polygon fill="#C30000" points="17.02,40.857 7.192,31.031 7.192,17.07 17.02,7.244 30.979,7.244 40.809,17.07 40.809,31.031 
+			30.979,40.857 		"/>
+		<polygon fill="#C40000" points="17.035,40.824 7.229,31.018 7.229,17.086 17.035,7.281 30.966,7.281 40.771,17.086 40.771,31.018 
+			30.966,40.824 		"/>
+		<polygon fill="#C50000" points="17.049,40.789 7.263,31.004 7.263,17.103 17.049,7.317 30.95,7.317 40.736,17.103 40.736,31.004 
+			30.95,40.789 		"/>
+		<polygon fill="#C60000" points="17.064,40.755 7.299,30.99 7.299,17.119 17.064,7.354 30.936,7.354 40.701,17.119 40.701,30.99 
+			30.936,40.755 		"/>
+		<polygon fill="#C70000" points="17.079,40.721 7.334,30.977 7.334,17.135 17.079,7.391 30.921,7.391 40.665,17.135 40.665,30.977 
+			30.921,40.721 		"/>
+		<polygon fill="#C80000" points="17.094,40.688 7.371,30.964 7.371,17.151 17.094,7.428 30.906,7.428 40.63,17.151 40.63,30.964 
+			30.906,40.688 		"/>
+		<polygon fill="#C90000" points="17.108,40.652 7.406,30.949 7.406,17.167 17.108,7.464 30.893,7.464 40.594,17.167 40.594,30.949 
+			30.893,40.652 		"/>
+		<polygon fill="#CA0000" points="17.123,40.618 7.441,30.936 7.441,17.182 17.123,7.5 30.877,7.5 40.559,17.182 40.559,30.936 
+			30.877,40.618 		"/>
+		<polygon fill="#CB0000" points="17.138,40.584 7.477,30.923 7.477,17.199 17.138,7.537 30.861,7.537 40.523,17.199 40.523,30.923 
+			30.861,40.584 		"/>
+		<polygon fill="#CC0000" points="17.153,40.55 7.513,30.909 7.513,17.215 17.153,7.574 30.848,7.574 40.486,17.215 40.486,30.909 
+			30.848,40.55 		"/>
+		<polygon fill="#CC0000" points="17.167,40.516 7.548,30.896 7.548,17.23 17.167,7.611 30.832,7.611 40.452,17.23 40.452,30.896 
+			30.832,40.516 		"/>
+		<polygon fill="#CD0000" points="17.182,40.48 7.583,30.882 7.583,17.246 17.182,7.647 30.816,7.647 40.416,17.246 40.416,30.882 
+			30.816,40.48 		"/>
+		<polygon fill="#CE0000" points="17.197,40.445 7.619,30.868 7.619,17.262 17.197,7.685 30.803,7.685 40.381,17.262 40.381,30.868 
+			30.803,40.445 		"/>
+		<polygon fill="#CF0000" points="17.211,40.412 7.654,30.855 7.654,17.278 17.211,7.721 30.788,7.721 40.346,17.278 40.346,30.855 
+			30.788,40.412 		"/>
+		<polygon fill="#D00000" points="17.226,40.378 7.69,30.842 7.69,17.294 17.226,7.758 30.773,7.758 40.311,17.294 40.311,30.842 
+			30.773,40.378 		"/>
+		<polygon fill="#D10000" points="17.241,40.344 7.726,30.828 7.726,17.311 17.241,7.794 30.759,7.794 40.273,17.311 40.273,30.828 
+			30.759,40.344 		"/>
+		<polygon fill="#D20000" points="17.256,40.311 7.761,30.814 7.761,17.326 17.256,7.831 30.744,7.831 40.238,17.326 40.238,30.814 
+			30.744,40.311 		"/>
+		<polygon fill="#D30000" points="17.271,40.273 7.796,30.801 7.796,17.342 17.271,7.868 30.729,7.868 40.203,17.342 40.203,30.801 
+			30.729,40.273 		"/>
+		<polygon fill="#D40000" points="17.285,40.24 7.832,30.787 7.832,17.358 17.285,7.905 30.715,7.905 40.168,17.358 40.168,30.787 
+			30.715,40.24 		"/>
+		<polygon fill="#D50000" points="17.3,40.206 7.868,30.773 7.868,17.374 17.3,7.941 30.7,7.941 40.132,17.374 40.132,30.773 
+			30.7,40.206 		"/>
+		<polygon fill="#D60000" points="17.315,40.172 7.903,30.761 7.903,17.39 17.315,7.979 30.686,7.979 40.098,17.39 40.098,30.761 
+			30.686,40.172 		"/>
+		<polygon fill="#D70000" points="17.33,40.139 7.938,30.747 7.938,17.406 17.33,8.015 30.67,8.015 40.062,17.406 40.062,30.747 
+			30.67,40.139 		"/>
+		<polygon fill="#D80000" points="17.344,40.104 7.974,30.732 7.974,17.422 17.344,8.052 30.654,8.052 40.025,17.422 40.025,30.732 
+			30.654,40.104 		"/>
+		<polygon fill="#D90000" points="17.359,40.068 8.01,30.721 8.01,17.438 17.359,8.089 30.641,8.089 39.99,17.438 39.99,30.721 
+			30.641,40.068 		"/>
+		<polygon fill="#DA0000" points="17.374,40.034 8.045,30.706 8.045,17.454 17.374,8.125 30.626,8.125 39.954,17.454 39.954,30.706 
+			30.626,40.034 		"/>
+		<polygon fill="#DB0000" points="17.389,40 8.081,30.691 8.081,17.47 17.389,8.162 30.611,8.162 39.919,17.47 39.919,30.691 
+			30.611,40 		"/>
+		<polygon fill="#DC0000" points="17.403,39.966 8.116,30.68 8.116,17.486 17.403,8.199 30.598,8.199 39.884,17.486 39.884,30.68 
+			30.598,39.966 		"/>
+		<polygon fill="#DD0000" points="17.418,39.932 8.152,30.665 8.152,17.502 17.418,8.235 30.582,8.235 39.848,17.502 39.848,30.665 
+			30.582,39.932 		"/>
+		<polygon fill="#DE0000" points="17.433,39.896 8.188,30.652 8.188,17.518 17.433,8.272 30.566,8.272 39.812,17.518 39.812,30.652 
+			30.566,39.896 		"/>
+		<polygon fill="#DF0000" points="17.448,39.863 8.223,30.639 8.223,17.534 17.448,8.309 30.553,8.309 39.775,17.534 39.775,30.639 
+			30.553,39.863 		"/>
+		<polygon fill="#E00000" points="17.462,39.828 8.258,30.625 8.258,17.55 17.462,8.346 30.537,8.346 39.741,17.55 39.741,30.625 
+			30.537,39.828 		"/>
+		<polygon fill="#E10000" points="17.477,39.794 8.294,30.611 8.294,17.565 17.477,8.383 30.521,8.383 39.706,17.565 39.706,30.611 
+			30.521,39.794 		"/>
+		<polygon fill="#E20000" points="17.492,39.76 8.33,30.598 8.33,17.582 17.492,8.419 30.508,8.419 39.67,17.582 39.67,30.598 
+			30.508,39.76 		"/>
+		<polygon fill="#E30000" points="17.507,39.727 8.365,30.584 8.365,17.598 17.507,8.456 30.493,8.456 39.635,17.598 39.635,30.584 
+			30.493,39.727 		"/>
+		<polygon fill="#E40000" points="17.521,39.691 8.4,30.57 8.4,17.614 17.521,8.493 30.479,8.493 39.6,17.614 39.6,30.57 
+			30.479,39.691 		"/>
+		<polygon fill="#E50000" points="17.536,39.657 8.436,30.559 8.436,17.63 17.536,8.529 30.464,8.529 39.562,17.63 39.562,30.559 
+			30.464,39.657 		"/>
+		<polygon fill="#E60000" points="17.551,39.623 8.472,30.544 8.472,17.646 17.551,8.566 30.449,8.566 39.527,17.646 39.527,30.544 
+			30.449,39.623 		"/>
+		<polygon fill="#E70000" points="17.566,39.589 8.507,30.529 8.507,17.662 17.566,8.603 30.436,8.603 39.492,17.662 39.492,30.529 
+			30.436,39.589 		"/>
+		<polygon fill="#E80000" points="17.581,39.555 8.542,30.518 8.542,17.678 17.581,8.64 30.419,8.64 39.457,17.678 39.457,30.518 
+			30.419,39.555 		"/>
+		<polygon fill="#E90000" points="17.595,39.52 8.578,30.503 8.578,17.693 17.595,8.676 30.404,8.676 39.422,17.693 39.422,30.503 
+			30.404,39.52 		"/>
+		<polygon fill="#EA0000" points="17.61,39.484 8.614,30.489 8.614,17.709 17.61,8.713 30.391,8.713 39.387,17.709 39.387,30.489 
+			30.391,39.484 		"/>
+		<polygon fill="#EB0000" points="17.625,39.451 8.649,30.477 8.649,17.726 17.625,8.75 30.375,8.75 39.352,17.726 39.352,30.477 
+			30.375,39.451 		"/>
+		<polygon fill="#EC0000" points="17.64,39.417 8.685,30.462 8.685,17.742 17.64,8.787 30.359,8.787 39.314,17.742 39.314,30.462 
+			30.359,39.417 		"/>
+		<polygon fill="#ED0000" points="17.654,39.383 8.72,30.449 8.72,17.757 17.654,8.823 30.346,8.823 39.279,17.757 39.279,30.449 
+			30.346,39.383 		"/>
+		<polygon fill="#EE0000" points="17.669,39.35 8.756,30.436 8.756,17.773 17.669,8.86 30.331,8.86 39.244,17.773 39.244,30.436 
+			30.331,39.35 		"/>
+		<polygon fill="#EF0000" points="17.684,39.312 8.792,30.422 8.792,17.79 17.684,8.897 30.316,8.897 39.208,17.79 39.208,30.422 
+			30.316,39.312 		"/>
+		<polygon fill="#F00000" points="17.699,39.279 8.827,30.408 8.827,17.805 17.699,8.934 30.302,8.934 39.173,17.805 39.173,30.408 
+			30.302,39.279 		"/>
+		<polygon fill="#F10000" points="17.713,39.245 8.862,30.395 8.862,17.821 17.713,8.971 30.286,8.971 39.137,17.821 39.137,30.395 
+			30.286,39.245 		"/>
+		<polygon fill="#F20000" points="17.728,39.211 8.898,30.381 8.898,17.837 17.728,9.007 30.271,9.007 39.102,17.837 39.102,30.381 
+			30.271,39.211 		"/>
+		<polygon fill="#F30000" points="17.743,39.177 8.934,30.367 8.934,17.853 17.743,9.044 30.257,9.044 39.066,17.853 39.066,30.367 
+			30.257,39.177 		"/>
+		<polygon fill="#F40000" points="17.758,39.143 8.969,30.354 8.969,17.869 17.758,9.081 30.242,9.081 39.029,17.869 39.029,30.354 
+			30.242,39.143 		"/>
+		<polygon fill="#F50000" points="17.772,39.107 9.004,30.341 9.004,17.885 17.772,9.117 30.229,9.117 38.995,17.885 38.995,30.341 
+			30.229,39.107 		"/>
+		<polygon fill="#F60000" points="17.787,39.073 9.04,30.327 9.04,17.901 17.787,9.154 30.213,9.154 38.959,17.901 38.959,30.327 
+			30.213,39.073 		"/>
+		<polygon fill="#F70000" points="17.802,39.039 9.076,30.312 9.076,17.917 17.802,9.191 30.198,9.191 38.924,17.917 38.924,30.312 
+			30.198,39.039 		"/>
+		<polygon fill="#F80000" points="17.816,39.005 9.111,30.3 9.111,17.933 17.816,9.228 30.184,9.228 38.889,17.933 38.889,30.3 
+			30.184,39.005 		"/>
+		<polygon fill="#F90000" points="17.832,38.971 9.146,30.286 9.146,17.949 17.832,9.265 30.169,9.265 38.854,17.949 38.854,30.286 
+			30.169,38.971 		"/>
+		<polygon fill="#FA0000" points="17.846,38.938 9.182,30.271 9.182,17.965 17.846,9.301 30.154,9.301 38.816,17.965 38.816,30.271 
+			30.154,38.938 		"/>
+		<polygon fill="#FB0000" points="17.861,38.902 9.218,30.259 9.218,17.981 17.861,9.338 30.139,9.338 38.782,17.981 38.782,30.259 
+			30.139,38.902 		"/>
+		<polygon fill="#FC0000" points="17.875,38.867 9.253,30.246 9.253,17.997 17.875,9.375 30.124,9.375 38.746,17.997 38.746,30.246 
+			30.124,38.867 		"/>
+		<polygon fill="#FD0000" points="17.891,38.833 9.289,30.232 9.289,18.013 17.891,9.411 30.109,9.411 38.711,18.013 38.711,30.232 
+			30.109,38.833 		"/>
+		<polygon fill="#FE0000" points="17.905,38.799 9.324,30.219 9.324,18.029 17.905,9.448 30.096,9.448 38.675,18.029 38.675,30.219 
+			30.096,38.799 		"/>
+		<path fill="#FF0000" d="M17.92,38.766l-8.56-8.561v-12.16l8.56-8.56h12.16l8.561,8.56v12.16l-8.561,8.561H17.92z"/>
+	</g>
+	
+		<linearGradient id="XMLID_46_" gradientUnits="userSpaceOnUse" x1="582" y1="-986.6099" x2="582" y2="-1015.8911" gradientTransform="matrix(1 0 0 -1 -558 -977)">
+		<stop  offset="0" style="stop-color:#FFFFFF"/>
+		<stop  offset="1" style="stop-color:#FF0000"/>
+	</linearGradient>
+	<path fill="url(#XMLID_46_)" d="M17.92,38.891L9.36,30.33V18.17l8.56-8.56h12.16l8.561,8.56v12.16l-8.561,8.561H17.92z"/>
+	<path d="M11.7,17.7l18.7,18.7l5.896-5.9L17.6,11.7l-5.9,5.9V17.7z"/>
+	<path d="M11.7,30.5l5.9,5.9l18.7-18.7L30.4,11.8L11.7,30.5z"/>
+</g>
+<g id="crop_x0020_marks">
+	<path fill="none" d="M48,48H0V0h48V48z"/>
+</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/configuration/config-files.png b/org.apache.click.eclipse/documentation/user-guide/images/configuration/config-files.png
new file mode 100644
index 0000000..8f365e3
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/configuration/config-files.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/controls/container-package-class-diagram.png b/org.apache.click.eclipse/documentation/user-guide/images/controls/container-package-class-diagram.png
new file mode 100644
index 0000000..68ae585
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/controls/container-package-class-diagram.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/controls/control-class-diagram.png b/org.apache.click.eclipse/documentation/user-guide/images/controls/control-class-diagram.png
new file mode 100644
index 0000000..2225219
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/controls/control-class-diagram.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/controls/control-package-class-diagram.png b/org.apache.click.eclipse/documentation/user-guide/images/controls/control-package-class-diagram.png
new file mode 100644
index 0000000..013c6dc
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/controls/control-package-class-diagram.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/controls/control-post-sequence-diagram.png b/org.apache.click.eclipse/documentation/user-guide/images/controls/control-post-sequence-diagram.png
new file mode 100644
index 0000000..b4f400e
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/controls/control-post-sequence-diagram.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/draft.png b/org.apache.click.eclipse/documentation/user-guide/images/draft.png
new file mode 100644
index 0000000..59673fe
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/draft.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/external.png b/org.apache.click.eclipse/documentation/user-guide/images/external.png
new file mode 100644
index 0000000..12c2c54
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/external.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/home.gif b/org.apache.click.eclipse/documentation/user-guide/images/home.gif
new file mode 100644
index 0000000..6784f5b
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/home.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/home.png b/org.apache.click.eclipse/documentation/user-guide/images/home.png
new file mode 100644
index 0000000..cbb711d
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/home.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/home.svg b/org.apache.click.eclipse/documentation/user-guide/images/home.svg
new file mode 100644
index 0000000..e803a31
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/home.svg
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In  -->
+<!DOCTYPE svg [
+	<!ENTITY st0 "fill-rule:nonzero;clip-rule:nonzero;fill:#FFFFFF;stroke:#000000;stroke-miterlimit:4;">
+	<!ENTITY st1 "fill:none;stroke:none;">
+	<!ENTITY st2 "fill:#000000;">
+	<!ENTITY st3 "fill:none;stroke:#FFFFFF;stroke-width:6.3469;stroke-linejoin:round;">
+	<!ENTITY st4 "fill-rule:evenodd;clip-rule:evenodd;stroke:none;">
+	<!ENTITY st5 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
+]>
+<svg  width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
+	<g id="Layer_x0020_3" style="&st0;">
+		<g style="&st4;">
+			<path style="&st3;" d="M22.9,7.1L5.1,21.8l0,0c-0.3,0.3-0.5,0.8-0.5,1.2c0,0.2,0,0.4,0.1,0.6c0.3,0.6,0.9,1,1.6,1c0,0,1.1,0,2.2,0c0,2.4,0,14.2,0,14.2c0,1.1,0.8,1.9,1.8,1.9h27.4c1.1,0,1.9-0.9,1.9-2c0,0,0-11.8,0-14.2c1,0,2,0,2,0c0.8,0,1.4-0.5,1.7-1.2
+				c0.1-0.2,0.1-0.4,0.1-0.6c0-0.5-0.2-1-0.7-1.4c0,0-3.6-3-4.5-3.7c0-1.2,0-6.9,0-6.9c0-1.2-0.8-2-2-2h-4.8c-1,0-1.7,0.6-1.9,1.5c-1.9-1.6-4.1-3.5-4.1-3.5l0.1,0.1c-0.7-0.7-1.8-0.8-2.7-0.1z"/>
+			<path style="&st2;" d="M22.9,7.1L5.1,21.8l0,0c-0.3,0.3-0.5,0.8-0.5,1.2c0,0.2,0,0.4,0.1,0.6c0.3,0.6,0.9,1,1.6,1c0,0,1.1,0,2.2,0c0,2.4,0,14.2,0,14.2c0,1.1,0.8,1.9,1.8,1.9h27.4c1.1,0,1.9-0.9,1.9-2c0,0,0-11.8,0-14.2c1,0,2,0,2,0c0.8,0,1.4-0.5,1.7-1.2
+				c0.1-0.2,0.1-0.4,0.1-0.6c0-0.5-0.2-1-0.7-1.4c0,0-3.6-3-4.5-3.7c0-1.2,0-6.9,0-6.9c0-1.2-0.8-2-2-2h-4.8c-1,0-1.7,0.6-1.9,1.5c-1.9-1.6-4.1-3.5-4.1-3.5l0.1,0.1c-0.7-0.7-1.8-0.8-2.7-0.1z"/>
+			<path style="&st2;" d="M41.8,22.8l-5.1-4.2v-0.1L31,13.7v0l-6.5-5.5C24.2,8,24,8,23.8,8.2L6.2,22.9c-0.1,0.1-0.1,0.3,0.1,0.3h1.6H10h28.1h1.2h2.3c0.2,0,0.4-0.2,0.2-0.4z"/>
+			<path d="M35.8,16.8l0-5.1c0-0.2-0.1-0.4-0.3-0.4h-3.2c-0.2,0-0.3,0.1-0.3,0.3v2.2l3.9,2.9z"/>
+			<path d="M11.9,24.7V37c0,0.3,0.1,0.4,0.3,0.4h23.6c0.3,0,0.4-0.2,0.4-0.4V24.7H11.9z"/>
+		</g>
+	</g>
+	<g id="crop_x0020_marks" style="&st5;">
+		<path style="&st1;" d="M48,48H0V0h48v48z"/>
+	</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/important.gif b/org.apache.click.eclipse/documentation/user-guide/images/important.gif
new file mode 100644
index 0000000..6795d9a
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/important.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/important.png b/org.apache.click.eclipse/documentation/user-guide/images/important.png
new file mode 100644
index 0000000..12c90f6
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/important.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/important.svg b/org.apache.click.eclipse/documentation/user-guide/images/important.svg
new file mode 100644
index 0000000..dd84f3f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/important.svg
@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In  -->
+<!DOCTYPE svg [
+	<!ENTITY st0 "fill:#FFFFFF;stroke:none;">
+	<!ENTITY st1 "fill:#FFFFFF;stroke-width:6.6112;stroke-linecap:round;stroke-linejoin:round;">
+	<!ENTITY st2 "stroke:#FFFFFF;stroke-width:6.6112;">
+	<!ENTITY st3 "fill:none;stroke:none;">
+	<!ENTITY st4 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
+	<!ENTITY st5 "stroke:none;">
+]>
+<svg  width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
+	<g id="Layer_x0020_3" style="&st4;">
+		<g>
+			<path style="&st2;" d="M41.7,35.3L26.6,9.4c-0.6-1-1.7-1.7-2.9-1.6c-1.2,0-2.3,0.7-2.9,1.7L6.3,35.4c-0.6,1-0.6,2.3,0,3.3c0.6,1,1.7,1.6,2.9,1.6h29.6c1.2,0,2.3-0.6,2.9-1.7c0.6-1,0.6-2.3,0-3.3z"/>
+			<path style="&st1;" d="M23.7,11L9.2,37h29.6L23.7,11z"/>
+			<path style="&st0;" d="M23.7,11.9L10.3,36.1h27.5l-14-24.1z"/>
+			<g>
+				<path style="&st5;" d="M24.1,34c-1.1,0-1.8-0.8-1.8-1.8c0-1.1,0.7-1.8,1.8-1.8c1.1,0,1.8,0.7,1.8,1.8c0,1-0.7,1.8-1.8,1.8h0z M22.9,29.3l-0.4-9.1h3.2l-0.4,9.1h-2.3z"/>
+			</g>
+		</g>
+	</g>
+	<g id="crop_x0020_marks" style="&st4;">
+		<path style="&st3;" d="M48,48H0V0h48v48z"/>
+	</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/important.tif b/org.apache.click.eclipse/documentation/user-guide/images/important.tif
new file mode 100644
index 0000000..184de63
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/important.tif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/introduction/advanced-form.png b/org.apache.click.eclipse/documentation/user-guide/images/introduction/advanced-form.png
new file mode 100644
index 0000000..3605cf0
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/introduction/advanced-form.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/introduction/advanced-table.png b/org.apache.click.eclipse/documentation/user-guide/images/introduction/advanced-table.png
new file mode 100644
index 0000000..3f88ca3
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/introduction/advanced-table.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/introduction/hello-world-screenshot.png b/org.apache.click.eclipse/documentation/user-guide/images/introduction/hello-world-screenshot.png
new file mode 100644
index 0000000..f9bfea8
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/introduction/hello-world-screenshot.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-form-error.png b/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-form-error.png
new file mode 100644
index 0000000..e321d3a
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-form-error.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-form-success.png b/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-form-success.png
new file mode 100644
index 0000000..497f626
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-form-success.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-form.png b/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-form.png
new file mode 100644
index 0000000..066515f
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-form.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-table.png b/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-table.png
new file mode 100644
index 0000000..d674552
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/introduction/simple-table.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/next.gif b/org.apache.click.eclipse/documentation/user-guide/images/next.gif
new file mode 100644
index 0000000..aa1516e
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/next.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/next.png b/org.apache.click.eclipse/documentation/user-guide/images/next.png
new file mode 100644
index 0000000..45835bf
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/next.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/next.svg b/org.apache.click.eclipse/documentation/user-guide/images/next.svg
new file mode 100644
index 0000000..75fa83e
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/next.svg
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In  -->
+<!DOCTYPE svg [
+	<!ENTITY st0 "fill:none;stroke:none;">
+	<!ENTITY st1 "fill:#FFFFFF;stroke:#FFFFFF;stroke-width:7.5901;stroke-linejoin:round;">
+	<!ENTITY st2 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
+	<!ENTITY st3 "stroke:none;">
+]>
+<svg  width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
+	<g id="Layer_x0020_3" style="&st2;">
+		<g>
+			<path style="&st1;" d="M22.4,41.1c0,0.3,0.3,0.3,0.5,0.2l16.6-16.9c0.5-0.5,0.4-0.7,0-1L22.9,6.7c-0.1-0.1-0.4-0.1-0.4,0.1v10H8.9c-0.3,0-0.5,0.2-0.5,0.4l0,13.3C8.4,30.9,8.6,31,9,31h13.5l-0.1,10.1z"/>
+			<path style="&st3;" d="M22.4,41.1c0,0.3,0.3,0.3,0.5,0.2l16.6-16.9c0.5-0.5,0.4-0.7,0-1L22.9,6.7c-0.1-0.1-0.4-0.1-0.4,0.1v10H8.9c-0.3,0-0.5,0.2-0.5,0.4l0,13.3C8.4,30.9,8.6,31,9,31h13.5l-0.1,10.1z"/>
+		</g>
+	</g>
+	<g id="crop_x0020_marks" style="&st2;">
+		<path style="&st0;" d="M48,48H0V0h48v48z"/>
+	</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/note.gif b/org.apache.click.eclipse/documentation/user-guide/images/note.gif
new file mode 100644
index 0000000..f329d35
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/note.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/note.png b/org.apache.click.eclipse/documentation/user-guide/images/note.png
new file mode 100644
index 0000000..d0c3c64
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/note.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/note.svg b/org.apache.click.eclipse/documentation/user-guide/images/note.svg
new file mode 100644
index 0000000..648299d
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/note.svg
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In  -->
+<!DOCTYPE svg [
+	<!ENTITY st0 "fill:none;stroke:#FFFFFF;stroke-width:12.1438;stroke-linejoin:round;">
+	<!ENTITY st1 "fill:none;stroke-width:1.2429;">
+	<!ENTITY st2 "fill:#FFFFFF;stroke:none;">
+	<!ENTITY st3 "fill:none;stroke:#FFFFFF;stroke-width:12.7649;stroke-linejoin:round;">
+	<!ENTITY st4 "fill:#FFFFFF;stroke-width:6.3824;stroke-linejoin:round;">
+	<!ENTITY st5 "fill:none;stroke:none;">
+	<!ENTITY st6 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
+	<!ENTITY st7 "fill:#FFFFFF;stroke:#FFFFFF;stroke-width:12.7649;stroke-linejoin:round;">
+	<!ENTITY st8 "stroke:none;">
+	<!ENTITY st9 "fill:none;stroke-width:4.9715;stroke-linejoin:round;">
+]>
+<svg  xmlns="http://www.w3.org/2000/svg" width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve">
+	<g id="Layer_x0020_1" style="&st6;">
+		<path style="&st0;" d="M35.7,19.8v18.9H11V8.8h13.9l10.8,11z"/>
+		<path style="&st3;" d="M38.7,30.4L25,16.7l-7.7-3l2.7,8.7l13.3,13.4l5.4-5.4z"/>
+		<path style="&st7;" d="M35.7,8.8H11v29.9h24.7V8.8z"/>
+		<path style="&st4;" d="M35.7,8.8H11v29.9h24.7V8.8z"/>
+		<path style="&st2;" d="M35.7,8.8H11v29.9h24.7V8.8z"/>
+	</g>
+	<g id="Layer_x0020_4" style="&st6;">
+		<path style="&st9;" d="M38.7,30.4L25,16.7l-7.7-3l2.7,8.7l13.3,13.4l5.4-5.4z"/>
+		<path style="&st8;" d="M38.7,30.4L25,16.7l-7.7-3l2.7,8.7l13.3,13.4l5.4-5.4z"/>
+		<path style="&st8;" d="M20.6,14.7l-2.5,2.5L17,13.4l3.6,1.3z"/>
+		<path style="&st1;" d="M19.6,22.2l3-0.3l2.4-2.4l0.4-2.8"/>
+		<path style="&st2;" d="M20.4,14.9L18.3,17l1.6,5.2l2.7-0.3l2.4-2.4l0.3-2.4l-5-2.2z"/>
+	</g>
+	<g id="crop" style="&st6;">
+		<path style="&st5;" d="M48,48H0V0h48v48z"/>
+	</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/note.tif b/org.apache.click.eclipse/documentation/user-guide/images/note.tif
new file mode 100644
index 0000000..08644d6
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/note.tif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/pages/activity-diagram-small.png b/org.apache.click.eclipse/documentation/user-guide/images/pages/activity-diagram-small.png
new file mode 100644
index 0000000..af5b3ff
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/pages/activity-diagram-small.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/pages/click-class-diagram.png b/org.apache.click.eclipse/documentation/user-guide/images/pages/click-class-diagram.png
new file mode 100644
index 0000000..0b6b97c
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/pages/click-class-diagram.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/pages/get-sequence-diagram.png b/org.apache.click.eclipse/documentation/user-guide/images/pages/get-sequence-diagram.png
new file mode 100644
index 0000000..1e5455b
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/pages/get-sequence-diagram.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/pages/home-page-screenshot.png b/org.apache.click.eclipse/documentation/user-guide/images/pages/home-page-screenshot.png
new file mode 100644
index 0000000..dac0abb
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/pages/home-page-screenshot.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/prev.gif b/org.apache.click.eclipse/documentation/user-guide/images/prev.gif
new file mode 100644
index 0000000..64ca8f3
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/prev.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/prev.png b/org.apache.click.eclipse/documentation/user-guide/images/prev.png
new file mode 100644
index 0000000..cf24654
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/prev.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/prev.svg b/org.apache.click.eclipse/documentation/user-guide/images/prev.svg
new file mode 100644
index 0000000..6d88ffd
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/prev.svg
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In  -->
+<!DOCTYPE svg [
+	<!ENTITY st0 "fill:none;stroke:none;">
+	<!ENTITY st1 "fill:#FFFFFF;stroke:#FFFFFF;stroke-width:7.5901;stroke-linejoin:round;">
+	<!ENTITY st2 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
+	<!ENTITY st3 "stroke:none;">
+]>
+<svg  width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
+	<g id="Layer_x0020_3" style="&st2;">
+		<g>
+			<path style="&st1;" d="M25.6,6.9c0-0.3-0.3-0.3-0.5-0.2L8.4,23.6c-0.5,0.5-0.4,0.7,0,1l16.6,16.6c0.1,0.1,0.4,0.1,0.4-0.1v-10h13.6c0.3,0,0.5-0.2,0.5-0.4l0-13.3c0-0.3-0.2-0.5-0.5-0.5H25.5l0.1-10.1z"/>
+			<path style="&st3;" d="M25.6,6.9c0-0.3-0.3-0.3-0.5-0.2L8.4,23.6c-0.5,0.5-0.4,0.7,0,1l16.6,16.6c0.1,0.1,0.4,0.1,0.4-0.1v-10h13.6c0.3,0,0.5-0.2,0.5-0.4l0-13.3c0-0.3-0.2-0.5-0.5-0.5H25.5l0.1-10.1z"/>
+		</g>
+	</g>
+	<g id="crop_x0020_marks" style="&st2;">
+		<path style="&st0;" d="M48,48H0V0h48v48z"/>
+	</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/tip.gif b/org.apache.click.eclipse/documentation/user-guide/images/tip.gif
new file mode 100644
index 0000000..823f2b4
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/tip.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/tip.png b/org.apache.click.eclipse/documentation/user-guide/images/tip.png
new file mode 100644
index 0000000..5c4aab3
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/tip.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/tip.svg b/org.apache.click.eclipse/documentation/user-guide/images/tip.svg
new file mode 100644
index 0000000..4a64a15
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/tip.svg
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In  -->
+<!DOCTYPE svg [
+	<!ENTITY st0 "fill:none;stroke:#000000;stroke-width:1.0944;">
+	<!ENTITY st1 "fill:#FFFFFF;stroke:none;">
+	<!ENTITY st2 "fill-rule:nonzero;clip-rule:nonzero;stroke:#FFFFFF;stroke-width:5.6139;stroke-miterlimit:4;">
+	<!ENTITY st3 "fill:none;stroke:none;">
+	<!ENTITY st4 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
+	<!ENTITY st5 "stroke:none;">
+]>
+<svg  width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
+	<g id="Layer_x0020_3" style="&st2;">
+		<g>
+			<path d="M9.5,18.6c0,8,6.5,14.4,14.4,14.4c8,0,14.4-6.5,14.4-14.4c0-8-6.5-14.4-14.4-14.4c-8,0-14.4,6.5-14.4,14.4z M12.8,18.6c0-6.2,5-11.2,11.2-11.2c6.2,0,11.2,5,11.2,11.2c0,6.2-5,11.2-11.2,11.2c-6.2,0-11.2-5-11.2-11.2z"/>
+			<path d="M28.1,37.9l-7.6,0.8c-0.9,0.1-1.5,0.9-1.4,1.8c0.1,0.9,0.9,1.5,1.8,1.4l7.6-0.8c0.9-0.1,1.5-0.9,1.4-1.8c-0.1-0.9-0.9-1.5-1.8-1.4z"/>
+			<path d="M28.1,34.8l-7.6,0.8c-0.9,0.1-1.5,0.9-1.4,1.8c0.1,0.9,0.9,1.5,1.8,1.4l7.6-0.8c0.9-0.1,1.5-0.9,1.4-1.8c-0.1-0.9-0.9-1.5-1.8-1.4z"/>
+			<path d="M28.1,31.6l-7.6,0.8c-0.9,0.1-1.5,0.9-1.4,1.8s0.9,1.5,1.8,1.4l7.6-0.8c0.9-0.1,1.5-0.9,1.4-1.8s-0.9-1.5-1.8-1.4z"/>
+			<path d="M23.1,41.3v0.9c0,0.9,0.7,1.6,1.6,1.6c0.9,0,1.6-0.7,1.6-1.6v-0.9h-3.3z"/>
+			<path style="&st1;" d="M35.9,18.7c0,6.6-5.4,12-12,12c-6.6,0-12-5.4-12-12s5.4-12,12-12c6.6,0,12,5.4,12,12z"/>
+			<path style="&st5;" d="M9.6,18.6c0,8,6.5,14.4,14.4,14.4c8,0,14.4-6.5,14.4-14.4c0-8-6.5-14.4-14.4-14.4c-8,0-14.4,6.5-14.4,14.4z M12.9,18.6c0-6.2,5-11.2,11.2-11.2c6.2,0,11.2,5,11.2,11.2c0,6.2-5,11.2-11.2,11.2c-6.2,0-11.2-5-11.2-11.2z"/>
+			<path style="&st5;" d="M28.2,37.9l-7.6,0.8c-0.9,0.1-1.5,0.9-1.4,1.8c0.1,0.9,0.9,1.5,1.8,1.4l7.6-0.8c0.9-0.1,1.5-0.9,1.4-1.8c-0.1-0.9-0.9-1.5-1.8-1.4z"/>
+			<path style="&st5;" d="M28.2,34.7l-7.6,0.8c-0.9,0.1-1.5,0.9-1.4,1.8c0.1,0.9,0.9,1.5,1.8,1.4l7.6-0.8c0.9-0.1,1.5-0.9,1.4-1.8c-0.1-0.9-0.9-1.5-1.8-1.4z"/>
+			<path style="&st5;" d="M28.2,31.6l-7.6,0.8c-0.9,0.1-1.5,0.9-1.4,1.8c0.1,0.9,0.9,1.5,1.8,1.4l7.6-0.8c0.9-0.1,1.5-0.9,1.4-1.8c-0.1-0.9-0.9-1.5-1.8-1.4z"/>
+			<path style="&st5;" d="M23.1,41.3v0.9c0,0.9,0.7,1.6,1.6,1.6s1.6-0.7,1.6-1.6v-0.9h-3.3z"/>
+			<path style="&st0;" d="M22.3,28.3l-3.5-10.7c0,0,6.6,3.9,10.5,0"/>
+		</g>
+	</g>
+	<g id="crop_x0020_marks" style="&st4;">
+		<path style="&st3;" d="M48,48H0V0h48v48z"/>
+	</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/tip.tif b/org.apache.click.eclipse/documentation/user-guide/images/tip.tif
new file mode 100644
index 0000000..4a3d8c7
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/tip.tif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/toc-blank.png b/org.apache.click.eclipse/documentation/user-guide/images/toc-blank.png
new file mode 100644
index 0000000..6ffad17
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/toc-blank.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/toc-minus.png b/org.apache.click.eclipse/documentation/user-guide/images/toc-minus.png
new file mode 100644
index 0000000..abbb020
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/toc-minus.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/toc-plus.png b/org.apache.click.eclipse/documentation/user-guide/images/toc-plus.png
new file mode 100644
index 0000000..941312c
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/toc-plus.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/up.gif b/org.apache.click.eclipse/documentation/user-guide/images/up.gif
new file mode 100644
index 0000000..aabc2d0
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/up.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/up.png b/org.apache.click.eclipse/documentation/user-guide/images/up.png
new file mode 100644
index 0000000..07634de
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/up.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/up.svg b/org.apache.click.eclipse/documentation/user-guide/images/up.svg
new file mode 100644
index 0000000..d31aa9c
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/up.svg
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In  -->
+<!DOCTYPE svg [
+	<!ENTITY st0 "fill:none;stroke:none;">
+	<!ENTITY st1 "fill:#FFFFFF;stroke:#FFFFFF;stroke-width:7.5901;stroke-linejoin:round;">
+	<!ENTITY st2 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
+	<!ENTITY st3 "stroke:none;">
+]>
+<svg  width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
+	<g id="Layer_x0020_3" style="&st2;">
+		<g>
+			<path style="&st1;" d="M41.1,25.6c0.3,0,0.3-0.3,0.2-0.5L24.4,8.4c-0.5-0.5-0.7-0.4-1,0L6.7,25.1c-0.1,0.1-0.1,0.4,0.1,0.4h10v13.6c0,0.3,0.2,0.5,0.4,0.5l13.3,0c0.3,0,0.5-0.2,0.5-0.5V25.5l10.1,0.1z"/>
+			<path style="&st3;" d="M41.1,25.6c0.3,0,0.3-0.3,0.2-0.5L24.4,8.4c-0.5-0.5-0.7-0.4-1,0L6.7,25.1c-0.1,0.1-0.1,0.4,0.1,0.4h10v13.6c0,0.3,0.2,0.5,0.4,0.5l13.3,0c0.3,0,0.5-0.2,0.5-0.5V25.5l10.1,0.1z"/>
+		</g>
+	</g>
+	<g id="crop_x0020_marks" style="&st2;">
+		<path style="&st0;" d="M48,48H0V0h48v48z"/>
+	</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/warning.gif b/org.apache.click.eclipse/documentation/user-guide/images/warning.gif
new file mode 100644
index 0000000..3adf191
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/warning.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/warning.png b/org.apache.click.eclipse/documentation/user-guide/images/warning.png
new file mode 100644
index 0000000..1c33db8
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/warning.png
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/warning.svg b/org.apache.click.eclipse/documentation/user-guide/images/warning.svg
new file mode 100644
index 0000000..fc8d748
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/warning.svg
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="iso-8859-1"?>
+<!-- Generator: Adobe Illustrator 9.0, SVG Export Plug-In  -->
+<!DOCTYPE svg [
+	<!ENTITY st0 "fill:#000000;stroke:#FFFFFF;stroke-width:7.9139;stroke-linejoin:round;">
+	<!ENTITY st1 "fill-rule:nonzero;clip-rule:nonzero;fill:#FFFFFF;stroke:#000000;stroke-miterlimit:4;">
+	<!ENTITY st2 "fill:none;stroke:none;">
+	<!ENTITY st3 "fill:#000000;">
+	<!ENTITY st4 "fill-rule:evenodd;clip-rule:evenodd;stroke:none;">
+	<!ENTITY st5 "fill-rule:nonzero;clip-rule:nonzero;stroke:#000000;stroke-miterlimit:4;">
+]>
+<svg  width="48pt" height="48pt" viewBox="0 0 48 48" xml:space="preserve" xmlns="http://www.w3.org/2000/svg">
+	<g id="Layer_x0020_4" style="&st1;">
+		<g style="&st4;">
+			<path style="&st0;" d="M16.4,42.3L5.7,31.6V16.4L16.4,5.7h15.2l10.7,10.7v15.2L31.6,42.3H16.4z"/>
+			<path style="&st3;" d="M16.4,42.3L5.7,31.6V16.4L16.4,5.7h15.2l10.7,10.7v15.2L31.6,42.3H16.4z"/>
+			<path d="M11.7,17.7l18.7,18.7l5.9-5.9L17.6,11.7l-5.9,5.9z"/>
+			<path d="M11.7,30.5l5.9,5.9l18.7-18.7l-5.9-5.9L11.7,30.5z"/>
+		</g>
+	</g>
+	<g id="crop_x0020_marks" style="&st5;">
+		<path style="&st2;" d="M48,48H0V0h48v48z"/>
+	</g>
+</svg>
diff --git a/org.apache.click.eclipse/documentation/user-guide/images/warning.tif b/org.apache.click.eclipse/documentation/user-guide/images/warning.tif
new file mode 100644
index 0000000..7b6611e
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/images/warning.tif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/user-guide/index.html b/org.apache.click.eclipse/documentation/user-guide/index.html
new file mode 100644
index 0000000..0eabafe
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/user-guide/index.html
@@ -0,0 +1,3 @@
+<html><head>
+      <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+   <title>Apache Click</title><link rel="stylesheet" href="css/stylesheet.css" type="text/css"><meta name="generator" content="DocBook XSL Stylesheets V1.75.0"><link rel="home" href="index.html" title="Apache Click"><link rel="next" href="ch01.html" title="Chapter&nbsp;1.&nbsp;Introduction to Apache Click"></head><body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="3" align="center">Apache Click</th></tr><tr><td width="20%" align="left">&nbsp;</td><th width="60%" align="center">&nbsp;</th><td width="20%" align="right">&nbsp;<a accesskey="n" href="ch01.html">Next</a></td></tr></table><hr></div><div lang="en" class="book" title="Apache Click"><div class="titlepage"><div><div><h1 class="title"><a name="d0e2"></a>Apache Click</h1></div><div><div class="authorgroup"><h3 class="corpauthor">Apache Click User Guide</h3></div></div><div><div class="mediaobject"><img src="images/click-logo.png"></div></div><div><p class="releaseinfo">V 2.1.0</p></div><div><p class="copyright">Copyright &copy; 2009 The Apache Software Foundation</p></div></div><hr></div><div class="toc"><p><b>Table of Contents</b></p><dl><dt><span class="chapter"><a href="ch01.html">1. Introduction to Apache Click</a></span></dt><dd><dl><dt><span class="sect1"><a href="ch01.html#hello-world">1.1. Hello World Example</a></span></dt><dt><span class="sect1"><a href="ch01s02.html">1.2. Control Listener Type 1 Example</a></span></dt><dt><span class="sect1"><a href="ch01s03.html">1.3. Control Listener Type 2 Example</a></span></dt><dt><span class="sect1"><a href="ch01s04.html">1.4. Simple Table Example</a></span></dt><dt><span class="sect1"><a href="ch01s05.html">1.5. Advanced Table Example</a></span></dt><dt><span class="sect1"><a href="ch01s06.html">1.6. Simple Form Example</a></span></dt><dt><span class="sect1"><a href="ch01s07.html">1.7. Advanced Form Example</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch01s07.html#form-layout">1.7.1. Form Layout</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="ch02.html">2. Pages</a></span></dt><dd><dl><dt><span class="sect1"><a href="ch02.html#classes">2.1. Classes</a></span></dt><dt><span class="sect1"><a href="ch02s02.html">2.2. Execution</a></span></dt><dt><span class="sect1"><a href="ch02s03.html">2.3. Request Parameter Auto Binding</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch02s03.html#customizing-auto-binding">2.3.1. Customizing Auto Binding</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch02s04.html">2.4. Security</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch02s04.html#applications-authentication">2.4.1. Application Authentication</a></span></dt><dt><span class="sect2"><a href="ch02s04.html#container-authentication">2.4.2. Container Authentication</a></span></dt><dt><span class="sect2"><a href="ch02s04.html#container-access-control">2.4.3. Container Access Control</a></span></dt><dt><span class="sect2"><a href="ch02s04.html#logging-out">2.4.4. Logging Out</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch02s05.html">2.5. Page Navigation</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch02s05.html#forward">2.5.1. Forward</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch02s05.html#forward-parameter-passing">2.5.1.1. Forward Parameter Passing</a></span></dt><dt><span class="sect3"><a href="ch02s05.html#page-forwarding">2.5.1.2. Page Forwarding</a></span></dt></dl></dd><dt><span class="sect2"><a href="ch02s05.html#template-path">2.5.2. Template Path</a></span></dt><dt><span class="sect2"><a href="ch02s05.html#redirect">2.5.3. Redirect</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch02s05.html#redirect-parameter-passing">2.5.3.1. Redirect Parameter Passing</a></span></dt><dt><span class="sect3"><a href="ch02s05.html#post-redirect">2.5.3.2. Post Redirect</a></span></dt></dl></dd></dl></dd><dt><span class="sect1"><a href="ch02s06.html">2.6. Page Templating</a></span></dt><dt><span class="sect1"><a href="ch02s07.html">2.7. Direct Rendering</a></span></dt><dt><span class="sect1"><a href="ch02s08.html">2.8. Stateful Pages</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch02s08.html#page-creation">2.8.1. Page Creation</a></span></dt><dt><span class="sect2"><a href="ch02s08.html#page-execution">2.8.2. Page Execution</a></span></dt><dt><span class="sect2"><a href="ch02s08.html#page-destruction">2.8.3. Page Destruction</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch02s09.html">2.9. Error Handling</a></span></dt><dt><span class="sect1"><a href="ch02s10.html">2.10. Page Not Found</a></span></dt><dt><span class="sect1"><a href="ch02s11.html">2.11. Page Message Properties</a></span></dt><dt><span class="sect1"><a href="ch02s12.html">2.12. Page HEAD Elements</a></span></dt></dl></dd><dt><span class="chapter"><a href="ch03.html">3. Controls</a></span></dt><dd><dl><dt><span class="sect1"><a href="ch03.html#control-interface">3.1. Control Interface</a></span></dt><dt><span class="sect1"><a href="ch03s02.html">3.2. Control Callback</a></span></dt><dt><span class="sect1"><a href="ch03s03.html">3.3. Control Classes</a></span></dt><dt><span class="sect1"><a href="ch03s04.html">3.4. Message Properties</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch03s04.html#message-resolution">3.4.1. Message Resolution</a></span></dt><dt><span class="sect2"><a href="ch03s04.html#control-properties">3.4.2. Control Properties</a></span></dt><dt><span class="sect2"><a href="ch03s04.html#accessing-messages">3.4.3. Accessing Messages</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch03s05.html">3.5. Control HEAD Elements</a></span></dt><dt><span class="sect1"><a href="ch03s06.html">3.6. Container</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch03s06.html#abstractcontainer">3.6.1. AbstractContainer</a></span></dt><dt><span class="sect2"><a href="ch03s06.html#abstractcontainerfield">3.6.2. AbstractContainerField</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch03s07.html">3.7. Layouts</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch03s07.html#template-layout">3.7.1. Template layout</a></span></dt><dt><span class="sect2"><a href="ch03s07.html#programmatic-layout">3.7.2. Programmatic layout</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="ch04.html">4. Configuration</a></span></dt><dd><dl><dt><span class="sect1"><a href="ch04.html#servlet-configuration">4.1. Servlet Configuration</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch04.html#servlet-mapping">4.1.1. Servlet Mapping</a></span></dt><dt><span class="sect2"><a href="ch04.html#load-on-startup">4.1.2. Load On Startup</a></span></dt><dt><span class="sect2"><a href="ch04.html#type-converter-class">4.1.3. Type Converter Class</a></span></dt><dt><span class="sect2"><a href="ch04.html#config-service-class">4.1.4. Config Service Class</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch04s02.html">4.2. Application Configuration</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch04s02.html#click-app">4.2.1. Click App</a></span></dt><dt><span class="sect2"><a href="ch04s02.html#application-pages">4.2.2. Pages</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch04s02.html#application-multiple-packages">4.2.2.1. Multiple Pages Packages</a></span></dt></dl></dd><dt><span class="sect2"><a href="ch04s02.html#application-page">4.2.3. Page</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch04s02.html#application-automapping">4.2.3.1. Page Automapping</a></span></dt><dt><span class="sect3"><a href="ch04s02.html#application-excludes">4.2.3.2. Automapping Excludes</a></span></dt><dt><span class="sect3"><a href="ch04s02.html#application-autobinding">4.2.3.3. Page Autobinding</a></span></dt><dt><span class="sect3"><a href="ch04s02.html#application-autobinding-annotation">4.2.3.4. Page Autobinding - Using Annotations</a></span></dt></dl></dd><dt><span class="sect2"><a href="ch04s02.html#application-headers">4.2.4. Headers</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch04s02.html#browser-caching">4.2.4.1. Browser Caching</a></span></dt></dl></dd><dt><span class="sect2"><a href="ch04s02.html#application-format">4.2.5. Format</a></span></dt><dt><span class="sect2"><a href="ch04s02.html#application-mode">4.2.6. Mode</a></span></dt><dd><dl><dt><span class="sect3"><a href="ch04s02.html#page-auto-loading">4.2.6.1. Page Auto Loading</a></span></dt><dt><span class="sect3"><a href="ch04s02.html#click-logging">4.2.6.2. Click and Velocity Logging</a></span></dt></dl></dd><dt><span class="sect2"><a href="ch04s02.html#application-controls">4.2.7. Controls</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch04s03.html">4.3. Auto Deployed Files</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch04s03.html#deploying-restricted-env">4.3.1. Deploying resources in a restricted environment</a></span></dt><dt><span class="sect2"><a href="ch04s03.html#deploying-custom-resources">4.3.2. Deploying Custom Resources</a></span></dt></dl></dd></dl></dd><dt><span class="chapter"><a href="ch05.html">5. Best Practices</a></span></dt><dd><dl><dt><span class="sect1"><a href="ch05.html#security">5.1. Security</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch05.html#declarative-security">5.1.1. Declarative Security</a></span></dt><dt><span class="sect2"><a href="ch05.html#alternatve-security-solutions">5.1.2. Alternative Security solutions</a></span></dt><dt><span class="sect2"><a href="ch05.html#resources">5.1.3. Resources</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch05s02.html">5.2. Packages and Classes</a></span></dt><dd><dl><dt><span class="sect2"><a href="ch05s02.html#page-classes">5.2.1. Page Classes</a></span></dt></dl></dd><dt><span class="sect1"><a href="ch05s03.html">5.3. Page Auto Mapping</a></span></dt><dt><span class="sect1"><a href="ch05s04.html">5.4. Navigation</a></span></dt><dt><span class="sect1"><a href="ch05s05.html">5.5. Templating</a></span></dt><dt><span class="sect1"><a href="ch05s06.html">5.6. Menus</a></span></dt><dt><span class="sect1"><a href="ch05s07.html">5.7. Logging</a></span></dt><dt><span class="sect1"><a href="ch05s08.html">5.8. Error Handling</a></span></dt><dt><span class="sect1"><a href="ch05s09.html">5.9. Performance</a></span></dt></dl></dd></dl></div></div><div class="navfooter"><hr><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left">&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right">&nbsp;<a accesskey="n" href="ch01.html">Next</a></td></tr><tr><td width="40%" align="left" valign="top">&nbsp;</td><td width="20%" align="center">&nbsp;</td><td width="40%" align="right" valign="top">&nbsp;Chapter&nbsp;1.&nbsp;Introduction to Apache Click</td></tr></table></div></body></html>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/documentation/velocity/VelocityUsersGuide.pdf b/org.apache.click.eclipse/documentation/velocity/VelocityUsersGuide.pdf
new file mode 100644
index 0000000..decfda5
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/velocity/VelocityUsersGuide.pdf
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/velocity/developer-guide.html b/org.apache.click.eclipse/documentation/velocity/developer-guide.html
new file mode 100644
index 0000000..795fdf5
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/velocity/developer-guide.html
@@ -0,0 +1,3758 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+<!-- Content Stylesheet for Site -->
+
+        
+<!-- start the processing -->
+    <!-- ====================================================================== -->
+    <!-- Main Page Section -->
+    <!-- ====================================================================== -->
+    <html>
+        <head>
+            <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"/>
+
+                                                    <meta name="author" value="Velocity Documentation Team">
+            <meta name="email" value="geirm@apache.org">
+            
+           
+                                    
+            <title>Velocity - Developer's Guide</title>
+            <style>
+              a:visited { color: blue; }
+              body	{ font-family: arial, helvetica, sans-serif; }
+            </style>
+        </head>
+
+        <body bgcolor="#ffffff" text="#000000" link="#525D76">        
+
+            <table border="0" width="100%" cellspacing="4">
+
+      <tr><td bgcolor="#525D76">&nbsp;
+        <font size="+2" color="#ffffff" face="arial,helvetica,sanserif">
+          <strong>Velocity Developers Guide</strong>
+        </font>
+      </td></tr>
+
+                <tr><td colspan="2">
+                    <hr noshade="" size="1"/>
+                </td></tr>                
+
+                <tr><td width="80%" align="left" valign="top">
+                                                                    <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Contents"><strong>Contents</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+<ol>
+
+<li>
+<a href="developer-guide.html#Introduction">Introduction and Getting Started</a>
+</li>
+
+<li>
+<a href="developer-guide.html#Resources">Resources</a>
+</li>
+
+<li>
+<a href="developer-guide.html#How Velocity Works">How Velocity Works</a>
+<ul>
+ <li><a href="developer-guide.html#The Fundamental Pattern">The Fundamental Pattern</a></li>
+</ul>
+</li>
+
+<li>
+<a href="developer-guide.html#To Singleton Or Not To Singleton...">To Singleton Or Not To Singleton...</a>
+<ul>
+  <li><a href="developer-guide.html#Singleton">Singleton Model</a></li>
+  <li><a href="developer-guide.html#Separate">Separate Instance</a></li>
+</ul>
+</li>
+
+<li>
+<a href="developer-guide.html#The Context">The Context</a>
+<ul>
+<li><a href="developer-guide.html#The Basics">The Basics</a></li>
+<li><a href="developer-guide.html#Support for Iterative Objects for #foreach()">Support for Iterative Objects for #foreach()</a></li>
+<li><a href="developer-guide.html#Context Chaining">Context Chaining</a></li>
+<li><a href="developer-guide.html#Objects Created in the Template">Objects Created by the Template</a></li>
+<li><a href="developer-guide.html#Other Context Issues">Other Context Issues</a></li>
+</ul>
+</li>
+
+<li>
+<a href="developer-guide.html#Using Velocity In Servlets">Using Velocity in Servlets</a>
+<ul>
+<li><a href="developer-guide.html#Servlet Programming">Servlet Programming</a></li>
+<li><a href="developer-guide.html#Deployment">Deployment</a></li>
+</ul>
+</li>
+
+<li>
+<a href="developer-guide.html#Using Velocity In General Applications">Using Velocity in General Applications</a>
+<ul>
+<li><a href="developer-guide.html#The Velocity Helper Class">The Velocity Helper Class</a></li>
+<li><a href="developer-guide.html#Exceptions">Exceptions</a></li>
+<li><a href="developer-guide.html#Miscellaneous Details">Miscellaneous Details</a></li>
+</ul>
+</li>
+
+<li>
+  <a href="developer-guide.html#Application Attributes">Application Attributes</a>
+</li>
+
+<li>
+<a href="developer-guide.html#EventCartridge and Event Handlers">EventCartridge and Event Handlers</a>
+</li>
+
+<li>
+<a href="developer-guide.html#Velocity Configuration Keys and Values">Velocity Configuration Keys and Values</a>
+</li>
+
+<li>
+<a href="developer-guide.html#Configuring the Log System">Configuring the Log System</a>
+ <ul>
+  <li>
+    <a href="developer-guide.html#Using Log4j With Existing Category">Using Log4j With Existing Category</a>
+  </li>
+  <li>
+    <a href="developer-guide.html#Simple Example of a Custom Logger">Simple Example of a Custom Logger</a>
+  </li>
+ </ul>
+</li>
+
+<li>
+<a href="developer-guide.html#Configuring Resource Loaders">Configuring the Resource Loaders (template loaders)</a>
+<ul>
+  <li>
+    <a href="developer-guide.html#Resource Loaders">Resource Loaders</a>
+  </li>
+  <li>
+    <a href="developer-guide.html#Configuration Examples">Configuration Examples</a>
+  </li>
+  <li>
+    <a href="developer-guide.html#Resource Manager and Cache">Pluggable Resource Manager and Resource Cache</a>
+  </li>
+ </ul>
+</li>
+
+<li>
+<a href="developer-guide.html#Template Encoding for Internationalization">Template Encoding for Internationalization</a>
+</li>
+
+<li>
+<a href="developer-guide.html#Velocity and XML">Velocity and XML</a>
+</li>
+
+<li>
+<a href="developer-guide.html#FAQ (Frequently Asked Questions)">FAQ (Frequently Asked Questions)</a>
+</li>
+
+<li>
+<a href="developer-guide.html#Summary">Summary</a>
+</li>
+
+<li>
+<a href="developer-guide.html#Appendix 1 : Deploying the Example Servlet">Appendix 1 : Deploying the Example Servlet</a>
+<ul>
+  <li>
+    <a href="developer-guide.html#TomcatExample">Jakarta Tomcat</a>
+  </li>
+  <li>
+    <a href="developer-guide.html#ResinExample">Caucho Technology's Resin</a>
+  </li>
+  <li>
+    <a href="developer-guide.html#WebLogic">BEA WebLogic</a>
+  </li>
+ </ul>
+</li>
+
+</ol>
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Introduction"><strong>Introduction</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+Velocity is a Java-based template engine, a simple and powerful development tool
+that allows you to easily create and render documents that format and present
+your data. In this guide, we hope to give an overview of the basics of
+development using Velocity, focusing on the two main areas for Velocity usage :
+</p>
+                                                <ul>
+<li>servlet-based WWW development</li>
+<li>general application use</li>
+</ul>
+                                                <p>
+You will see that there is no real difference between these, other than we make
+servlet development with Velocity very easy if you use our provided class
+VelocityServlet as a base class for your servlet, and offer a utility class to
+help with application development.
+</p>
+                                                <p>
+<strong>Getting Started</strong>
+</p>
+                                                <p>
+While this information is found elsewhere on the Velocity site and in the
+documentation, it is included here for completeness. Getting Velocity running on
+your computer is very easy.  Note that all directory references are relative the
+root of the Velocity distribution tree.
+<ol>
+  <li>
+    Get the Velocity distribution. This is available as a release, nightly snapshot or
+    directly from the CVS code repository. Any are fine, although for the latest
+    features, the nightly snapshot is most likely the best way. For more
+    information, go <a href="index.html">here</a>.
+  </li>
+  <li>
+    If you don't have <a href="http://jakarta.apache.org/ant/">Jakarta Ant</a>,
+    the Java build tool already installed, please do so.  It is required for
+    building Velocity, although not required for <i>using</i> Velocity.
+  </li>
+  <li>
+    Go to the <code>build</code> directory in the distribution.
+  </li>
+  <li>
+    Type <code>ant &lt;build target&gt;</code> where &lt;build target&gt;
+    is one of:
+    <ul>
+      <li>
+        <b><code>jar</code></b> builds the complete Velocity jar in the
+        <code>bin</code> directory.  This jar will be called 'velocity-X.jar',
+        where 'X' is the current version number. This jar does not include
+        necessary dependencies for Velocity.  If you use this
+        target, you must get the Collections component jar from Jakarta Commons and add
+        to your CLASSPATH (or WEB-INF/lib).
+        If you wish to use the built-in logging or template conversion,
+        you must include the appropriate jars in your CLASSPATH or
+        webapp's WEB-INF/lib.
+        For convenience, you can use the <code>jar-dep</code> target to build
+        a jar with ORO, Logkit and Commons Collections included.
+      </li>
+      <li>
+        <b><code>jar-dep</code></b> builds the complete Velocity jar in
+        the <code>bin</code> directory, including necessary
+        support for logging from the
+        <a href="http://jakarta.apache.org/avalon/logkit/index.html">Jakarta
+        Avalon Logkit</a> package, critical configuration support from the
+        <a href="http://jakarta.apache.org/commons/">Jakarta Commons</a>
+        and the necesary support for WebMacro
+        template conversion using the
+        <a href="http://jakarta.apache.org/oro/index.html">Jakarta ORO</a>
+        package.
+       </li>
+       <li>
+        <b><code>jar-core</code></b> builds a slimmer Velocity jar in the
+        <code>bin</code> directory, called 'velocity-core-X.jar'. This jar
+        contains the core Velocity functionality, and doesn't include example
+        and utility things like Anakia, Texen or the VelocityServlet support
+        baseclass.  It has the same external dependency requirements as the
+        regular <code>jar</code> target.
+      </li>
+      <li>
+        <b><code>jar-util</code></b> builds a utility Velocity jar in the
+        <code>bin</code> directory, called 'velocity-util-X.jar'. This jar
+        contains utility code, specifically Anakia, Texen, and the WebMacro
+        template conversion utility. It has the same external dependency requirements as the
+        regular <code>jar</code> target.
+      </li>
+      <li>
+        <b><code>jar-servlet</code></b> builds a utility Velocity jar in the
+        <code>bin</code> directory, called 'velocity-servlet-X.jar'. This jar
+        contains utility code for servlet programmers. It has the same external dependency requirements as the
+        regular <code>jar</code> target.
+      </li>
+      <li>
+        <b><code>jar-J2EE</code></b> builds a complete jar, like the 'jar' target,
+        that includes any components that require J2EE support. Currently, this
+        includes only org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader.
+        As usual, it is placed in the  <code>bin</code> directory, called
+        'velocity-j2ee-X.jar'. NOTE : if you wish to use this build target, you
+        must place (or link) a copy of j2ee.jar into the build/lib directory.
+        We do not provide it as part of the distribution. A good source is
+        http://java.sun.com/.  It has the same external dependency requirements as the
+        regular <code>jar</code> target.
+      </li>
+      <li>
+        <b><code>jar-J2EE-dep</code></b> build a complete jar with J2EE support
+        and includes logging support from the Jakarta Avalon Logkit and
+        regexp support fromt the Jakarta ORO package. See the notes on the
+        <code>jar-dep</code> target, above.
+      </li>
+      <li>
+        <b><code>examples</code></b> builds the example code in the example programs
+        found in the <code>examples</code> directory. This build target will
+        also build the forumdemo example project.
+      </li>
+      <li>
+        <b><code>forumdemo</code></b> builds the example webapplication in the
+        <code>examples/forumdemo</code> directory.
+      </li>
+      <li>
+        <b><code>docs</code></b> builds these docs in the <code>docs</code> directory
+        using Velocity's <a href="anakia.html">Anakia</a> XML transformation tool.
+        Allowing you to use
+        Velocity templates in place of stylesheets
+        - give it a try!  <i>Note: This target requires that the jakarta-site2 project
+        is located as a peer directory to the jakarta-velocity distribution directory.
+        Please see the note in the build.xml file for this target for further information.</i>
+      </li>
+      <li>
+        <b><code>jar-src</code></b> bundles all the Velocity source code into a single
+        jar, placed in the <code>bin</code> directory.
+      </li>
+      <li>
+        <b><code>javadocs</code></b> builds the Javadoc class documentation in the
+        <code>docs/api</code> directory
+      </li>
+      <li>
+        <b><code>test</code></b> (after jar) will test Velocity against it's testbed
+        suite of test routines
+      </li>
+      <li>
+        <b><code>help</code></b> lists the build targets that are available.
+      </li>
+    </ul>
+  </li>
+  <li>
+    While not required, testing the build is a good idea. Use the
+    <code>test</code> target mentioned above.
+  </li>
+  <li>
+    That's it! Velocity is ready to be used. Put the jar into your classpath, or
+    into other appropriate places (such as the lib directory of your webapp if
+    using with servlets)
+  </li>
+  <li>
+    If you want to play with the examples, which is highly recommended when
+    getting started, use build the examples via
+    <code>ant examples</code>.
+  </li>
+</ol>
+</p>
+                                                <strong>Dependencies</strong>
+                                                <p>
+Velocity uses elements of the Java 2 API such as collections, and therefore
+building requires the Java 2 Standard Edition SDK (Software Development Kit).
+To run Velocity, the Java 2 Standard Edition RTE (Run Time Environment)
+is required (or you can use the SDK, of course).
+</p>
+                                                <p>
+Velocity also is dependent upon a few packages for general functionality.  They
+are included in the <code>build/lib</code> directory for convenience, but
+the default build target (see above) does not include them.  If you use the
+default build target, you must add the dependencies to your classpath.
+</p>
+                                                <ul>
+<li>
+  <a href="http://jakarta.apache.org/commons/">
+  <b>Jakarta Commons Collections</b></a> - required.
+</li>
+<li>
+  <a href="http://jakarta.apache.org/avalon/logkit/index.html">
+  <b>Jakarta Avalon Logkit</b></a> - optional, but very common.
+  Needed if using the default file-based logging in Velocity.
+</li>
+<li>
+  <a href="http://jakarta.apache.org/oro/index.html"><b>Jakarta ORO</b></a>
+   - optional.  Needed when using the
+   <code>org.apache.velocity.convert.WebMacro</code> template conversion
+   utility.
+ </li>
+</ul>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Resources"><strong>Resources</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+There are quite a few resources and examples available to the programmer, and we
+recommend that you look at our examples, documentation and even the source code.
+Some great sources are :
+</p>
+                                                <ul>
+  <li>
+     The user and developer community : join us via the
+     <a href="http://jakarta.apache.org/getinvolved/mail.html">mail-lists</a>.
+  </li>
+  <li>
+     Mail-list archives : <a href="http://www.mail-archive.com">
+    http://www.mail-archive.com</a> is a good one.  Type 'velocity' into the search
+    box to see both our -user and -dev archives.
+  </li>
+  <li>
+    source code : <code>src/java/...</code> : all the source code to the
+    Velocity project
+  </li>
+  <li>
+    application example 1 : <code>examples/app_example1</code> : a simple
+    example showing how to use Velocity in an application program.
+  </li>
+  <li>
+    application example 2 : <code>examples/app_example2</code> : a simple
+    example showing how to use Velocity in an application program using the
+    Velocity application utility class.
+  </li>
+  <li>
+    servlet example : <code>examples/servlet_example1</code> : a simple example
+    showing how to use Velocity in a servlet.
+  </li>
+  <li>
+    logger example : <code>examples/logger_example</code> : a simple example
+    showing how to create a custom logging class and register it with
+    Velocity to receive all log messages.
+  </li>
+  <li>
+    XML example : <code>examples/xmlapp_example</code> : a simple example
+    showing how to use JDOM to read and access XML document data from
+    within a Velocity template.  It also includes a demonstration of
+    a recursive Velocimacro that walks the document tree.
+  </li>
+ <li>
+    event example : <code>examples/event_example</code> : An example that
+    demonstrates the use of the event handling API in Velocity 1.1
+  </li>
+  <li>
+    Anakia application : <code>examples/anakia</code> : example application
+    showing how to use Velocity for creating stylesheet renderings of xml data
+  </li>
+  <li>
+    Forumdemo web app : <code>examples/forumdemo</code> : working example of a
+    simple servlet-based forum application
+  </li>
+  <li>
+    documentation : <code>docs</code> : all the generated documentation for the
+    Velocity project in html
+  </li>
+  <li>
+    API documentation : <code>docs/api</code> : the generated Javadoc
+    documentation for the Velocity project
+  </li>
+  <li>
+    templates : <code>test/templates</code> : a large collection of template
+    examples in our testbed directory, these are a great source of useage
+    examples of VTL, the Velocity Template Language
+  </li>
+  <li>
+    context example : <code>examples/context_example</code> : two examples
+    showing how the Velocity context can be extended. For advanced users.
+  </li>
+</ul>
+                                                <p>
+All directory references above are relative to the distribution root directory.
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="How Velocity Works"><strong>How Velocity Works</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+<a name="The Fundamental Pattern"><strong>'The Fundamental Pattern'</strong></a>
+</p>
+                                                <p>
+When using Velocity in an application program or in a servlet
+(or anywhere, actually), you will generally do the following :
+</p>
+                                                <ol>
+<li>Initialize Velocity. This applies to both usage patterns for Velocity,
+    the Singleton as well as the 'separate runtime instance' (see more on this
+    below), and you only do this once.</li>
+<li>Create a Context object (more on what that is later).</li>
+<li>Add your data objects to the Context.</li>
+<li>Choose a template.</li>
+<li>'Merge' the template and your data to produce the ouput.</li>
+</ol>
+                                                <p>
+In code, using the singleton pattern via the
+<code>org.apache.velocity.app.Velocity</code> class,
+this looks like
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+import java.io.StringWriter;
+import org.apache.velocity.VelocityContext;
+import org.apache.velocity.Template;
+import org.apache.velocity.app.Velocity;
+import org.apache.velocity.exception.ResourceNotFoundException;
+import org.apache.velocity.exception.ParseErrorException;
+import org.apache.velocity.exception.MethodInvocationException;
+
+Velocity.init();
+
+VelocityContext context = new VelocityContext();
+
+context.put( &quot;name&quot;, new String(&quot;Velocity&quot;) );
+
+Template template = null;
+
+try
+{
+   template = Velocity.getTemplate(&quot;mytemplate.vm&quot;);
+}
+catch( ResourceNotFoundException rnfe )
+{
+   // couldn't find the template
+}
+catch( ParseErrorException pee )
+{
+  // syntax error : problem parsing the template
+}
+catch( MethodInvocationException mie )
+{
+  // something invoked in the template
+  // threw an exception
+}
+catch( Exception e )
+{}
+
+StringWriter sw = new StringWriter();
+
+template.merge( context, sw );
+
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+That's the basic pattern. It is very simple, isn't it?  This is generally what
+happens when you use Velocity to render a template. You probably won't be
+writing code exactly like this - we provide a few tools to help make it even
+easier than this for both servlet and application programmers.
+Later on in this guide, we will talk about using Velocity in both servlets
+as well as general applications, and we discuss the tools we provide to make
+things easier. In each case, though, the above sequence is what is happening
+either explicitly, or behind the scenes.
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="To Singleton Or Not To Singleton..."><strong>To Singleton Or Not To Singleton...</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+As of Velocity 1.2 and later, developers now have two options
+for using the Velocity engine, the singleton model and the separate instance
+model.  The same core Velocity code is used for both approaches, which are
+provided to make Velocity easier to integrate into your Java application.
+</p>
+                                                <p>
+<a name="Singleton"><strong>Singleton Model</strong></a>
+</p>
+                                                <p>
+   This is the legacy pattern, where there is only one instance of the Velocity
+   engine in the JVM (or web application, depending) that is shared by all.
+   This is very convenient as it
+   allows localized configuration and sharing of resources.  For example, this
+   is a very appropriate model for use in a Servlet 2.2+ compliant web application
+   as each web application can have it's own instance of Velocity, allowing
+   that web application's servlet to share resources like templates, a logger, etc.
+   The singleton is accessable via the <code>org.apache.velocity.app.Velocity</code>
+   class, and and example of use :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+
+import org.apache.velocity.app.Velocity;
+import org.apache.velocity.Template;
+
+...
+
+/*
+ *  Configure the engine - as an example, we are using
+ *  ourselves as the logger - see logging examples
+ */
+
+Velocity.setProperty( Velocity.RUNTIME_LOG_LOGSYSTEM, this);
+
+/*
+ *  now initialize the engine
+ */
+
+Velocity.init();
+
+...
+
+Template t = Velocity.getTemplate(&quot;foo.vm&quot;);
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+Please note that the Singleton model is used in the
+<code>org.apache.velocity.servlet.VelocityServlet</code> base class,
+a utility class provided with the distribution to make writing servlets
+easier.  While extending this class is the most common and convenient
+way to write servlets using Velocity, you are free to not use this
+class if you needs require something different.
+</p>
+                                                <p>
+<a name="Separate"><strong>Separate Instance</strong></a>
+</p>
+                                                <p>
+   New in version 1.2, the separate instance allows you to create, configure
+   and use as many instances of Velocity as you wish in the same JVM
+   (or web application.)  This
+   is useful when you wish to support separate configurations, such as template
+   directories, loggers, etc in the same application.  To use separate
+   instances, use the <code>org.apache.velocity.app.VelocityEngine</code>
+   class.  An example, which parallels the above singleton example, looks
+   like :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+
+import org.apache.velocity.app.VelocityEngine;
+import org.apache.velocity.Template;
+
+...
+
+/*
+ *  create a new instance of the engine
+ */
+
+VelocityEngine ve = new VelocityEngine();
+
+/*
+ *  configure the engine.  In this case, we are using
+ *  ourselves as a logger (see logging examples..)
+ */
+
+ve.setProperty( VelocityEngine.RUNTIME_LOG_LOGSYSTEM, this);
+
+/*
+ *  initialize the engine
+ */
+
+ve.init();
+
+...
+
+Template t = ve.getTemplate(&quot;foo.vm&quot;);
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+As you can see, this is very simple and straightforward.  Except for some simple
+syntax changes, using Velocity as a singleton or as separate instances requires
+no changes to the high-level structure of your application or templates.
+</p>
+                                                <p>
+As a programmer, the classes you should use to interact with the Velocity
+internals are the <code>org.apache.velocity.app.Velocity</code> class if
+using the singleton model, or <code>org.apache.velocity.app.VelocityEngine</code>
+if using the non-singleton model ('separate instance').
+</p>
+                                                <p>
+At no time should an application use the internal <code>Runtime, RuntimeConstants,
+RuntimeSingleton or RuntimeInstance</code> classes in the
+<code>org.apache.velocity.runtime</code> package, as these are intended for
+internal use only and may change over time.  As mentioned above,
+the classes you should use
+are located in the <code>org.apache.velocity.app</code> package, and are the
+<code>Velocity</code> and <code>VelocityEngine</code> classes.  If anything is
+missing or needed from those classes, do not hesitate to suggest changes - these
+classes are intended for the application developer.
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="The Context"><strong>The Context</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <a name="The Basics"><strong>The Basics</strong></a>
+                                                <p>
+The concept of the 'context' is central to Velocity, and is a common technique
+for moving a container of data around between parts of a system. The idea is
+that the context is a 'carrier' of data between the Java layer (or you the
+programmer) and the template layer ( or the designer ). You as the programmer
+will gather objects of various types, whatever your application calls for, and
+place them in the context.  To the designer, these objects, and their methods
+and properties, will become accessable via template elements called
+<a href="vtl-reference-guide.html"> references</a>. Generally, you will work
+with the designer to determine the data needs for the application. In a sense,
+this will become an 'API'  as you produce a data set for the designer to access
+in the template.  Therefore, in this phase of  the development process it is
+worth devoting some time and careful analysis.
+</p>
+                                                <p>
+While Velocity allows you to create your own context classes to support special
+needs and techniques (like a context that accesses an LDAP server directly, for
+example), a good basic implementation class called VelocityContext is provided
+for you as part of the distribution.
+</p>
+                                                <p>
+VelocityContext is suitable for all general purpose needs, and we strongly
+recommended that you use it. Only in exceptional and advanced cases will you
+need to extend or create your own context implementation.
+</p>
+                                                <p>
+Using VelocityContext is as simple as using a normal Java Hashtable class.
+While the interface contains other useful methods, the two main methods you
+will use are
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+public Object put(String key, Object value);
+public Object get(String key);
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+Please note that like a Hashtable, the value must be derived from
+java.lang.Object, and must not be null. Fundamental types like int or float must
+be wrapped in the appropriate wrapper classes.
+</p>
+                                                <p>
+That's really all there is to basic context operations. For more information,
+see the API documentation included in the distribution.
+</p>
+                                                <p>
+<a name="Support for Iterative Objects for #foreach()"><strong>Support for Iterative Objects for
+#foreach()</strong></a>
+</p>
+                                                <p>
+As a programmer, you have great freedom in the objects that you put into the
+context.  But as with most freedoms, this one comes with a little bit of
+responsibility, so understand what Velocity supports, and any issues that may
+arise.  Velocity supports serveral types of collection types  suitable for use
+in the VTL <code>#foreach()</code> directive.
+</p>
+                                                <ul>
+
+<li> <code>Object [] </code>  Regular object array, not much needs to be said
+here. Velocity will internally wrap your array in a class that provides an
+Iterator interface,  but that shouldn't concern you as the programmer, or the
+template author.
+</li>
+
+<li> <code>java.util.Collection</code>  Velocity will use the
+<code>iterator()</code> method to get an Iterator to use in the loop,
+so if you are implementing a Collection interface on your object, please
+ensure that <code>iterator()</code> returns a working  Iterator.
+</li>
+
+<li> <code>java.util.Map </code> Here, Velocity depends upon the
+<code>values()</code> method of the interface to get a <code>Collection</code>
+interface, on which <code>iterator()</code> is called to retrieve an Iterator
+for the loop.
+</li>
+
+<li> <code>java.util.Iterator</code> USE WITH CAUTION : This is currently
+supported only provisionally - the issue of concern is the
+'non-resettablity' of the Iterator.  If a 'naked' Iterator is placed into
+the context, and used in more than one #foreach(), subsequent #foreach()
+blocks after the first will fail, as the Iterator doesn't reset.
+</li>
+
+<li> <code>java.util.Enumeration</code> USE WITH CAUTION : Like
+<code>java.util.Iterator</code>, this is currently
+supported only provisionally - the issue of concern is the
+'non-resettablity' of the Enumeration.  If a 'naked' Enumeration
+is placed into the context, and used in more than one #foreach(),
+subsequent #foreach() blocks after the first will fail,
+as the Enumeration doesn't reset.
+</li>
+
+</ul>
+                                                <p>
+In the case of the <code>Iterator</code> and <code>Enumeration</code>, it is
+recommended that they are placed in the context only when it cannot be avoided,
+and you should let Velocity find the appropriate reusable iterative interface when
+that is sufficient and possible.
+</p>
+                                                <p>
+There are good reasons to use the <code>java.util.Iterator</code> interface
+directly (large data sets via JDBC, for example), but if it can be
+avoided, it might be better to use something else. By 'directly' , we meant
+doing something like:
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+Vector v = new Vector();
+v.addElement(&quot;Hello&quot;);
+v.addElement(&quot;There&quot;);
+
+context.put(&quot;words&quot;, v.iterator() );
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+where the Iterator itself is placed into the context. Instead, if you
+simply did:
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+context.put(&quot;words&quot;, v );
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+then all would be fine: Velocity would figure out that Vector implement
+Collection (via List), and therefore will find the <code>iterator()</code>
+method, and use that to get a 'fresh' Iterator for its use each time
+it needs to.  With just a plain Iterator (the first snippet above...),
+once velocity has used it in a <code>#foreach()</code>, Velocity has
+no way of getting a new one to use for the next <code>#foreach()</code>
+it is used in.  The result is no output from any subsequent
+<code>#foreach()</code> blocks using that reference.
+</p>
+                                                <p>
+This above isn't meant to give the impression that iterating over
+collections in Velocity is something that requires great care and
+thought.  Rather, the opposite is true, in general.  Just be
+careful when you place an Iterator into the context.
+</p>
+                                                <a name="Context Chaining"><strong>Context Chaining</strong></a>
+                                                <p>
+An innovative feature of Velocity's context design is the concept
+of <i>context chaining</i>. Also sometimes referred to as
+<i>context wrapping</i>, this advanced feature allows you to connect
+separate contexts together in a manner that makes it appear as one
+'contiguous' context to the template.
+</p>
+                                                <p>
+This is best illustrated by an example :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+VelocityContext context1 = new VelocityContext();
+
+context1.put(&quot;name&quot;,&quot;Velocity&quot;);
+context1.put(&quot;project&quot;, &quot;Jakarta&quot;);
+context1.put(&quot;duplicate&quot;, &quot;I am in context1&quot;);
+
+VelocityContext context2 = new VelocityContext( context1 );
+
+context2.put(&quot;lang&quot;, &quot;Java&quot; );
+context2.put(&quot;duplicate&quot;, &quot;I am in context2&quot;);
+
+template.merge( context2, writer );
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+In the code above, we have set up context2 such that it <i>chains</i>
+context1.  This means that in the template, you can access any of
+the items that were put into either of the two VelocityContext objects,
+as long as there is no duplication of the keys used to add objects.
+If that is the case, as it is above for the key 'duplicate', the object
+stored in the nearest context in the chain will be available.  In this
+example above, the object returned would
+be the string "I am in context2".
+</p>
+                                                <p>
+Note that this duplication, or 'covering', of a context item does not in
+any way harm or alter the covered object.  So in the example above, the
+string "I am in context1" is alive and well, still accessable via
+context1.get("duplicate").  But in the example above, the value of the
+reference '$duplicate' in the template would be 'I am in context2',
+and the template has no access to the covered string 'I am in context1'.
+</p>
+                                                <p>
+Note also that you have to be careful when you are relying on the template
+to add information to a context that you will examine later after the
+rendering.  The changes to the context via <code>#set()</code> statements
+in a template will affect only the outer context.  So make sure that you
+don't discard the outer context, expecting the data from the template to
+have been placed onto the inner one.
+</p>
+                                                <p>
+This feature has many uses, the most common so far is providing layered
+data access and toolsets.
+</p>
+                                                <p>
+As mentioned before, the Velocity context mechanism is also extendable,
+but beyond the current scope of this guide. If you are interested,
+please see the classes in the package <code>org.apache.velocity.context</code>
+to see how the provided contexts are put together.  Futher, there are a few
+examples in the <code>examples/context_example</code> directory in the
+distribution which show alternate implementations, including [a goofy] one
+that uses a database as the backing storage.
+</p>
+                                                <p>
+Please note that these examples are unsupported and are there for
+demonstration/educational purposes only.
+</p>
+                                                <a name="Objects Created in the Template"><strong>Objects Created in the
+Template</strong></a>
+                                                <p>
+ There are two common situations where the Java code must deal with objects
+ created at runtime in the template :
+</p>
+                                                <p>
+When a template author calls a method of an object placed into
+the context by Java code.
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+#set($myarr = [&quot;a&quot;,&quot;b&quot;,&quot;c&quot;] )
+$foo.bar( $myarr )
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+When a template adds objects to the context, the Java code can access
+those objects after the merge process is complete.
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+#set($myarr = [&quot;a&quot;,&quot;b&quot;,&quot;c&quot;] )
+#set( $foo = 1 )
+#set( $bar = &quot;bar&quot;)
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+Dealing with these cases if very straighforward, as there are just a few
+things to know:
+</p>
+                                                <ul>
+    <li>
+    The VTL RangeOperator  [ 1..10 ]  and  ObjectArray ["a","b"] are
+    <code>java.util.ArrayList</code> objects when placed in the context
+    or passed to methods.   Therefore, your methods that are designed to
+    accept arrays created in the template should be written with this
+    in mind.
+    </li>
+    <li>
+    Numbers will be Integers in the context, and strings will be, of course, Strings.
+    </li>
+    <li>
+    Velocity will properly 'narrow' args to method calls, so calling
+    <code>setFoo( int i )</code> with an int placed into the
+    context via <code>#set()</code> will work fine.
+    </li>
+  </ul>
+                                                <a name="Other Context Issues"><strong>Other Context Issues</strong></a>
+                                                <p>
+One of the features provided by the VelocityContext
+(or any Context derived from AbstractContext) is
+node specific introspection caching.  Generally, you as a the developer
+don't need to worry about this when using the VelocityContext
+as your context.  However, there is currently one
+known usage pattern where you must be aware of this feature.
+</p>
+                                                <p>
+The VelocityContext will accumulate intropection information about the
+syntax nodes in a template as it visits those nodes.  So, in the following
+situation:
+</p>
+                                                <ul>
+<li>
+  You are iterating over the same template using the same VelocityContext
+  object.
+</li>
+<li>
+Template caching is off.
+</li>
+<li>
+You request the Template from getTemplate() on each iteration.
+</li>
+</ul>
+                                                <p>
+It is possible that your VelocityContext will appear to 'leak' memory
+(it is really just gathering more introspection information.)  What
+happens is that it accumulates template node introspection information
+for each template it visits, and as template caching is off, it appears
+to the VelocityContext that it is visiting a new template each time.
+Hence it gathers more introspection information and grows. It is highly
+recommended that you do one or more of the following :
+</p>
+                                                <ul>
+<li>Create a new VelocityContext for each excursion
+down through the template render process.   This will prevent the accumulation
+of introspection cache data.  For the case where you want to reuse the
+VelocityContext because it's populated with data or objects,
+ you can simply wrap the populated
+VelocityContext in another, and the 'outer' one will accumulate the
+introspection information, which you will just discard.  Ex.
+<code>VelocityContext useThis = new VelocityContext( populatedVC );</code>
+This works because the outer context will store the introspection
+cache data, and get any requested data from the inner context (as it is empty.)
+Be careful though - if your template places data into the context and it's
+expected that it will be used in the subsequent iterations, you will need to do
+one of the other fixes, as any template #set() statements will be stored in
+the outermost context. See the discussion in
+<a href="developer-guide.html#Context Chaining">Context chaining</a> for more
+information.
+</li>
+
+<li>
+Turn on template caching.  This will prevent the template from being re-parsed
+on each iteration, resulting the the VelocityContext being able to not only
+avoid adding to the introspection cache information, but be able to use it
+resulting in a performance improvement.
+</li>
+
+<li>
+Reuse the Template object for the duration of the loop iterations.
+Then you won't be forcing Velocity, if the cache is turned off, to
+reread and reparse the same template over and over, so the VelocityContext
+won't gather new introspection information each time.
+</li>
+</ul>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Using Velocity In Servlets"><strong>Using Velocity In Servlets</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <a name="Servlet Programming"><strong>Servlet Programming</strong></a>
+                                                <p>
+The most common use of Velocity is in the area of Java Servlet programming
+for the WWW.   There are many reasons why Velocity is well suited for this
+task, one of the primary ones is Velocity's enforcement of the
+separation of the presentation (or view) layer from the
+code layer.  There are many resources on this subject, including
+<a href="http://www.javaworld.com/javaworld/jw-12-1999/jw-12-ssj-jspmvc.html">
+this</a>.
+</p>
+                                                <p>
+The basic technique of using Velocity in a servlet environment is very simple.
+In a nutshell, all you must do is extend the provided VelocityServlet base class
+and implement a single method, <code>handleRequest()</code>.  That's really all that is
+required to use Velocity in your servlet development.
+</p>
+                                                <p>
+As of Velocity 1.1, there are two <code>handleRequest()</code> methods :
+
+<br />
+<br />
+
+<i><code>public Template handleRequest( Context )</code></i>
+
+<blockquote>
+  This is the older of the two methods.  This method requires that you
+  return a valid Template object.  If not valid, or <code>null</code>,
+  this is considered an error condition, and will result in the <a href="developer-guide.html#error()"><code>error()</code></a> error
+  handling method being called.  You may override the
+  <code>error()</code> if you wish.  If returning a <code>null</code> is
+  something you expect to do (for example, you will want to redirect
+  requests) it is recommended that you use the newer method, listed
+  next.
+</blockquote>
+  <br />
+
+<i><code>public Template handleRequest( HttpServletRequest, HttpServletResponse, Context )</code></i>
+
+<blockquote>
+   This is the newer of the two <code>handleRequest()</code> methods,
+   implemented in version 1.1. The difference with this method is that
+   the <code>HttpServletRequest</code> and
+   <code>HttpServletResponse</code> objects are passed to you as
+   arguments to the method, as well as in the <code>Context</code>.  The
+   other difference is that this method can return <code>null</code> to
+   indicate that all processing has been handled by the method, and that
+   Velocity should do nothing further than call
+   <a href="developer-guide.html#requestCleanup()"><code>requestCleanup()</code></a>.
+   This is extremely useful is you wish to redirect the request, for
+   example.
+</blockquote>
+
+As always, please refer to the Javadoc API documentation for the definitive and
+latest notes.
+</p>
+                                                <p>
+The following code is similar to the SampleServlet.java class included
+in the distribution in the examples directory.
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+public class SampleServlet extends VelocityServlet
+{
+    public Template handleRequest( HttpServletRequest request,
+                                   HttpServletResponse response,
+                                   Context context )
+    {
+
+        String p1 = &quot;Jakarta&quot;;
+        String p2 = &quot;Velocity&quot;;
+
+        Vector vec = new Vector();
+        vec.addElement( p1 );
+        vec.addElement( p2 );
+
+        context.put(&quot;list&quot;, vec );
+
+        Template template = null;
+
+        try
+        {
+            template =  getTemplate(&quot;sample.vm&quot;);
+        }
+        catch( ResourceNotFoundException rnfe )
+        {
+          // couldn't find the template
+        }
+        catch( ParseErrorException pee )
+        {
+          // syntax error : problem parsing the template
+        }
+        catch( Exception e )
+        {}
+
+        return template;
+    }
+}
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+Look familiar?  With the exception of creating the context object, which is
+done for you by the VelocityServlet base class, and  the  merge() step
+which is also done for you by the VelocityServlet base class, it's identical
+to the basic code pattern we mentioned at the beginning of this guide.
+We take the context, add our application data, and return a template.
+</p>
+                                                <p>
+The default <code>Context</code> object that is passed into the
+<code>handleRequest()</code> methods contains both the current
+<code>HttpServletRequest</code> and <code>HttpServletResponse</code>
+objects.  They are placed in the context using the the constants
+<code>VelocityServlet.REQUEST</code> (value = 'req') and
+<code>VelocityServlet.RESPONSE</code> (value = 'res')
+respectively.  To access and use these objects in your Java code :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+public Template handleRequest(  Context context )
+{
+    HttpServletRequest request =  (HttpServletRequest) context.get( REQUEST );
+    HttpServletResponse response =  (HttpServletResponse) context.get( RESPONSE );
+
+   ...
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+and in your templates:
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+#set($name = $req.getParameter('name') )
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+For more advanced uses,  the VelocityServlet base class allows you to override
+parts of the handling of the request processing.  The following methods may
+be overridden :
+<br />
+<br />
+
+<i><code> Properties loadConfiguration( ServletConfig )</code></i>
+<blockquote>
+  Allows you to override the normal configuration mechanism and add or
+  alter the configuation properties.  This is useful for overriding or
+  augmenting template and log paths, to set the absolute path into the
+  webapp root at runtime.
+</blockquote>
+
+<i><a name="createContext()">
+<code>Context createContext(HttpServletRequest, HttpServletResponse )</code></a></i>
+<blockquote>
+  Allows you to create the Context object yourself. This allows more advanced
+  techniques, such as chaining or pre-loading with tools or data.  The default
+  implementation simply returns a VelocityContext object with the request
+  and response objects placed inside.  The request and response objects are
+  wrapped in simple wrapper classes to avoid introspection problems that may
+  occurr in some servlet container implementations.  You can use the request
+  and repsponse objects normally, accessing methods of either from the
+  template.  Just note that they aren't specifically javax.servlet.XXXX
+  classes, if that is important to you.
+</blockquote>
+
+<i><code>void setContentType( HttpServletRequest,HttpServletResponse )</code></i>
+<blockquote>
+  Allows you to examine the request and set the content type yourself,
+  depending on the request or client.  The default implementation sets
+  the content type to be that either specified in the
+  velocity.properties, if any, or the default, "text/html" if not
+  specified in the properties.
+</blockquote>
+
+<i><code>void mergeTemplate( Template, Context, HttpServletResponse )</code></i>
+<blockquote>
+  Allows you to produce the output stream.  The VelocityServlet uses a
+  pool of very efficient Writer classes, so this would usually be
+  overridden in special situations.
+</blockquote>
+
+<i><a name="requestCleanup()"><code>void requestCleanup( HttpServletRequest,
+  HttpServletResponse , Context )</code></a></i>
+<blockquote>
+  Allows you to do any cleanup or resource reclamation at the end of the
+  request processing.  The default does nothing.
+</blockquote>
+
+<i><a name="error()"><code>protected void error( HttpServletRequest,
+  HttpServletResponse, Exception )</code></a></i>
+<blockquote>
+  Error handler that is called an exception occurrs in request
+  processing. Default implementation will send a simple HTML message
+  with stacktrace and exception information back to the user.  Override
+  for custom client messages and more advanced problem handling.
+</blockquote>
+
+For further information, please see the Javadoc API documentation.
+</p>
+                                                <a name="Deployment"><strong>Deployment</strong></a>
+                                                <p>
+When you deploy your Velocity-based servlets, you will certainly want to
+ensure that your properties file is used to configure the Velocity runtime.
+Under Tomcat, one way to accomplish this is by placing your velocity.properties
+file into the root directory of your web app (webapps/appname ) and then
+add the following to your WEB-INF/web.xml file :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+&lt;servlet&gt;
+  &lt;servlet-name&gt;MyServlet&lt;/servlet-name&gt;
+  &lt;servlet-class&gt;com.foo.bar.MyServlet&lt;/servlet-class&gt;
+  &lt;init-param&gt;
+      &lt;param-name&gt;properties&lt;/param-name&gt;
+      &lt;param-value&gt;/velocity.properties&lt;/param-value&gt;
+  &lt;/init-param&gt;
+&lt;/servlet&gt;
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+Assuming all is right, this will ensure that when MyServlet is loaded,
+it will use the velocity.properties file to initialize itself
+rather than relying on it's internal defaults.
+</p>
+                                                <p>
+Note that Velocity uses a singleton model for it's central core Runtime
+class, so it is a very good idea to put the velocity-XX.jar
+into the WEB-INF/lib directory in all web applications that use
+Velocity to ensure that the web app classloader is
+managing your Runtime instance, rather than putting it in the CLASSPATH
+or the top level lib directory of the servlet runner.
+</p>
+                                                <p>
+This deployment method will ensure that different web applications will
+not be subject to Velocity configuration conflicts.
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Using Velocity In General Applications"><strong>Using Velocity In General Applications</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+As Velocity was designed to be a general-use tool, it is just as useful in
+general application programs as it is servlets. In general, you can use the
+same programming pattern discussed at the beginning of this guide, but there
+are a few utility methods provided for application use, just like we provide
+the VelocityServlet base class for ease of use in servlet programming.
+The only new responsibility you have as the application programmer is to
+initialize the Velocity runtime engine, but that is easy.
+</p>
+                                                <a name="The Velocity Helper Class"><strong>The Velocity Helper Class</strong></a>
+                                                <p>
+Velocity contains an application utility class called Velocity
+( <code>org.apache.velocity.app.Velocity</code> ).  The purpose of this class
+is to provide the necessary methods required to initialize Velocity, as well as
+useful utility routines to make life easier in using Velocity. This class is
+documented  in the project's javadoc, so please look there for definitive
+details. This documentation is intended to be of a tutorial nature; therefore
+for compete API information, the Javadoc is the definitive source.
+</p>
+                                                <p>
+The Velocity runtime engine is a singleton instance that provides resource,
+logging and other services to all Velocity users running in the same JVM.
+Therefore, the runtime engine is initialized only once.  You can attempt to
+initialize Velocity more than once, but only the first initialization will
+apply.  The rest of the attempts will be ignored.  The Velocity utility
+class currently provides five methods used in configuration of the runtime engine.
+</p>
+                                                <p>
+The five configuration methods are :
+</p>
+                                                <ul>
+
+<li><code>setProperty( String key, Object o )</code><br />
+Sets the property <code>key</code> with the value <code>o</code>. The value
+is typically a String, but in special cases can also be a comma-separated
+list of values (in a single String, ex."foo, bar, woogie") as well as other
+things that will arise.
+</li>
+
+<li><code>Object getProperty( String key )</code><br />
+Returns the value of the property key.  Note that you must be aware of the
+type of the return value, as they can be things other than Strings.
+</li>
+
+<li><code>init()</code><br />
+Initializes the runtime with the default properties provided in the
+distribution.(These are listed below in the section pertaining to
+properties.)
+</li>
+
+<li><code>init( Properties p )</code><br /> Initialize the runtime with the
+properties contained in the <code>java.util.Properties</code> object passed
+as an argument.
+</li>
+
+<li><code>init( String filename )</code><br /> initilizes the runtime
+using the properties found in the properties file filename
+</li>
+
+</ul>
+                                                <p>
+Note that in each case, the default properties will be used as a base
+configuration, and any additional properties specified by the application
+will replace individual defaults.  Any default properties not overwritten
+will remain in effect.  This has the benefit that only the properties
+you are interested in changing need to be specified, rather
+than a complete set.
+</p>
+                                                <p>
+Another thing to note is that the <code>init()</code> calls may be called
+more than once without harm in an application.  However, the first call to any
+of the <code>init()</code> functions will configure the engine with the
+configuration properties set at that point, and any further configuration
+changes or <code>init()</code> calls will be ignored.
+</p>
+                                                <p>
+The most common approaches to initializing Velocity will be something like :
+</p>
+                                                <ol>
+<li> Setup the configuration values you wish to set in a file in the same
+format as org/apache/velocity/runtime/defaults/velocity.properties
+(the default set),  or in a <code>java.util.Properties</code>, and then
+call either <code>init( filename )</code> or <code>init( Properties )</code>
+</li>
+
+<li> Set the configuration values individually using <code>setProperty()</code>
+and then call <code>init()</code>.  This method is generally used by more advanced
+applications that already have their own configuration management system -
+this allows the application so configure Velocity based upon values it generates
+at runtime, for example.
+</li>
+</ol>
+                                                <p>
+Once the runtime is initialized, you can do with it what you wish.. This mostly
+revolves around rendering templates into an output stream, and the Velocity
+utility class allows you to do this easily.  Currently, here are the methods
+and a brief description of what they do :
+</p>
+                                                <ul>
+  <li>
+     <code> evaluate( Context context,  Writer out, String logTag,
+     String instring )</code><br />
+     <code>evaluate( Context context, Writer writer, String logTag,
+     InputStream instream )</code><br />
+     These methods will render the input, in either the form of String or
+     InputStream to an output Writer, using a Context that you provide.
+     This is a very convenienient method to use for token replacement of
+     strings, or if you keep 'templates' of VTL-containing content in a
+     place like a database or other non-file storage, or simply generate such
+     dynamically.
+  </li>
+
+  <li>
+    <code>invokeVelocimacro( String vmName, String namespace, String params[],
+    Context context, Writer writer )</code><br />
+    Allows direct access to Velocimacros.  This can also be accomplished
+    via the <code>evaluate()</code> method above  if you wish.  Here you
+    simply name the vm you wish to be called, create an array of args to the VM,
+    a Context of data, and Writer for the output.  Note that the VM args
+    must be the 'keys' of the data objects in the Context, rather than
+    literal data to be used as the arg.  This will probably change.
+  </li>
+
+  <li>
+    <code>mergeTemplate( String templateName, Context context, Writer writer )
+    </code><br />
+    Convenient access to the normal template handling and rendering services
+    of Velocity.  This method will take care of getting and rendering the
+    template.  It will take advantage of loading the template according
+    to the properties setting for the file resource loader, and therefore
+    provides the advantage of file and parsed template caching that Velocity
+    offers.  This is the most efficient way to access templates,
+    and is recommended unless you have special needs.
+  </li>
+
+  <li>
+    <code> boolean templateExists( String name ) </code><br />
+    Determines if a template <code>name</code> is able to be found by
+    the currently configured resource loaders.
+  </li>
+</ul>
+                                                <p>
+Once we know about these basic helpers, it is easy to write Java program
+that uses Velocity.  Here it is:
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+import java.io.StringWriter;
+import org.apache.velocity.app.Velocity;
+import org.apache.velocity.VelocityContext;
+
+public class Example2
+{
+    public static void main( String args[] )
+    {
+        /* first, we init the runtime engine.  Defaults are fine. */
+
+        Velocity.init();
+
+        /* lets make a Context and put data into it */
+
+        VelocityContext context = new VelocityContext();
+
+        context.put(&quot;name&quot;, &quot;Velocity&quot;);
+        context.put(&quot;project&quot;, &quot;Jakarta&quot;);
+
+        /* lets render a template */
+
+        StringWriter w = new StringWriter();
+
+        Velocity.mergeTemplate(&quot;testtemplate.vm&quot;, context, w );
+        System.out.println(&quot; template : &quot; + w );
+
+        /* lets make our own string to render */
+
+        String s = &quot;We are using $project $name to render this.&quot;;
+        w = new StringWriter();
+        Velocity.evaluate( context, w, &quot;mystring&quot;, s );
+        System.out.println(&quot; string : &quot; + w );
+    }
+}
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+When we run this program, and have the template <code> testtemplate.vm</code>
+in the same directory as our program (because we used the default
+configuration properties, and the defaul place to load templates
+from is the current directory...), our output should be :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+template : Hi!  This Velocity from the Jakarta project.
+
+string : We are using Jakarta Velocity to render this.
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+where the template we used, testtemplate.vm, is
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+Hi!  This $name from the $project project.
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+That's all there is to it!  Note that we didn't have to use both
+<code>mergeTemplate()</code> and <code>evaluate()</code> in our
+program.  They are both included there for demonstration purposes.
+You will probably use only one of the methods, but depending
+on you application requirements,  you are free to do what you wish.
+</p>
+                                                <p>
+This appears to be a little different from the 'fundamental pattern'
+that was mentioned at the beginning of this guide, but it really is the
+same thing.  First, you are making a context and filling it with
+the data needed.  Where this examples differs is that in the part of
+the above example where <code>mergeTemplate()</code> is used,
+<code>mergeTemplate()</code> is doing the work of getting the template
+and merging it for you, using the lower-level calls in the Runtime class.
+In the second example, you are making your template dynamically via the
+String, so that is analgous to the 'choose template' part of the process,
+and the <code>evaluate()</code> method does the merging for you using
+lower level calls.
+</p>
+                                                <p>
+So the example above sticks to the same simply pattern of using the Velocity
+template engine, but the utility functions do some of
+the repeated drudge work, or allow you other options for your
+template content other than template files.
+</p>
+                                                <a name="Exceptions"><strong>Exceptions</strong></a>
+                                                <p>
+There are three exceptions that Velocity will throw during the parse / merge cycle.
+This are additional to the exceptions that will come from IO problems, etc.
+They are found in the package <code>org.apache.velocity.exception</code> and are:
+</p>
+                                                <ol>
+<li>
+<code>ResourceNotFoundException</code><br />
+Thrown when the resource managment system cannot find a resource (template) that
+was requested.
+</li>
+
+<li>
+<code>ParseErrorException</code><br />
+Thrown when a VTL syntax error is found when parsing a resource (template).
+</li>
+
+<li>
+<code>MethodInvocationException</code><br />
+Thrown when a method of object in the context thrown an exception during
+render time.  This exception wraps the thrown exception and propogates it
+to the application.  This allows you to handle problems in your own objects
+at runtime.
+</li>
+</ol>
+                                                <p>
+In each case, a message is put into the runtime log.  For more information,
+see the Javadoc API documentation.
+</p>
+                                                <a name="Miscellaneous Details"><strong>Miscellaneous Details</strong></a>
+                                                <p>
+While the above example used the default properties, setting your own
+properties is very simple. All you have to do is make a properties file
+somewhere and pass the name of that file to the <code>init(String)</code>
+method of the Velocity utility class, or make a
+<code>java.util.Properties</code> object, add the desired properties and
+values, and pass that to the <code>init(Properties)</code> method.
+The latter method is convenient, because you can either fill it directly
+from a separate properties file via the <code>load()</code>  method, or even
+better, you can fill it dynamically from your own application / framework's
+property set at runtime.  This gives you the freedom to combine all of the
+properties for your app into one properties file.
+</p>
+                                                <p>
+If we wanted to use a different directory than the current directory to
+load our template from, we could do something like this :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+ ...
+
+import java.util.Properties;
+ ...
+
+public static void main( String args[] )
+{
+    /* first, we init the runtime engine.  */
+
+    Properties p = new Properties();
+    p.setProperty(&quot;file.resource.loader.path&quot;, &quot;/opt/templates&quot;);
+    Velocity.init( p );
+
+    /* lets make a Context and put data into it */
+
+ ...
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+And, assuming you have a directory <code>/opt/templates</code> and the template
+<code>testtemplate.vm</code> is in there, then things would work just fine.
+If you try this and have a problem, be sure to look at the velocity.log for
+information - the error messages are pretty good for figuring out what is wrong.
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Application Attributes"><strong>Application Attributes</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+<i>Application Attributes</i> are name-value pairs that can be associated with
+a RuntimeInstance (either via the <code>VelocityEngine</code> or
+the <code>Velocity</code> singleton) and accessed from any part of the Velocity
+engine that has access to the RuntimeInstance.
+</p>
+                                                <p>
+This feature was designed for applications that need to communicate between
+the application layer and custom parts of the Velocity engine, such as
+loggers, resource loaders, resource managers, etc.
+</p>
+                                                <p>
+The Application Attribute API is very simple.  From the application layer, there
+is a method of the <code>VelocityEngine</code> and the <code>Velocity</code>
+classes :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+
+    public void setApplicationAttribute( Object key, Object value );
+
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+through which an application can store on Object under an application (or
+internal component) specified key.  There are no restrictions on the key
+or the value.  The value for a key may be set at any time - it is not required
+that this be set before init() is called.
+</p>
+                                                <p>
+Internal components can access the key-value pairs if they have access to the
+object via the <code>RuntimeServices</code> interface, using the method
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+
+    public Object getApplicationAttribute( Object key );
+
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+Note that internal components cannot set the value of the key, just get it.
+if the internal component must communicate information to the application layer,
+it must do so via the Object passed as the value.
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="EventCartridge and Event Handlers"><strong>EventCartridge and Event Handlers</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+Starting in version 1.1, a fine-grain event handling system was added to Velocity.
+The EventCartridge is a class in which you register your event handlers, and then the
+EventCartridge acts as the delivery agent from which the Velocity engine will
+access the event handlers at merge time if needed.
+Currently, there are 3 events that can be handled, and all are found in the
+<code>org.apache.velocity.app.event</code> package.
+</p>
+                                                <p>
+<i><code>org.apache.velocity.app.event.NullSetEventHandler</code></i>
+
+<blockquote>
+When a #set() results in a null assignment, this is normally
+logged.  The <code>NullSetEventHandler</code> allows you to 'veto' the
+logging of this condition.
+<br />
+<pre>
+public interface NullSetEventHandler extends EventHandler
+{
+    public boolean shouldLogOnNullSet( String lhs, String rhs );
+}
+</pre>
+</blockquote>
+
+<i><code>org.apache.velocity.app.event.ReferenceInsertionEventHandler</code></i>
+<blockquote>
+A <code>ReferenceInsertionEventHandler</code> allows the
+developer to intercept each write of a reference ($foo) value to the output
+stream and modify that output.
+<pre>
+public interface  ReferenceInsertionEventHandler extends EventHandler
+{
+    public Object referenceInsert( String reference, Object value  );
+}
+</pre>
+</blockquote>
+
+<i><code>org.apache.velocity.app.event.MethodExceptionEventHandler</code></i>
+<blockquote>
+When a user-supplied method throws an exception, the
+<code>MethodExceptionEventHandler</code> is invoked with the Class, method name
+and thrown Exception.  The handler can either return a valid Object to be used
+as the return value of the method call, or throw the passed-in or new Exception,
+which will be wrapped and propogated to the user as a
+<code>MethodInvocationException</code>
+<pre>
+public interface MethodExceptionEventHandler extends EventHandler
+{
+    public Object methodException( Class claz, String method, Exception e )
+         throws Exception;
+}
+</pre>
+</blockquote>
+</p>
+                                                <p>
+<strong>Using the EventCartridge</strong>
+</p>
+                                                <p>
+Using the EventCartridge is fairly straightforward.  The following abbreviated
+example was taken from <code>org.apache.velocity.test.misc.Test</code>.
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+ ...
+
+import org.apache.velocity.app.event.EventCartridge;
+import org.apache.velocity.app.event.ReferenceInsertionEventHandler;
+import org.apache.velocity.app.event.MethodExceptionEventHandler;
+import org.apache.velocity.app.event.NullSetEventHandler;
+
+ ...
+
+public class Test implements ReferenceInsertionEventHandler,
+                             NullSetEventHandler,
+                             MethodExceptionEventHandler
+{
+    public void myTest()
+    {
+        ....
+
+        /*
+         *  now, it's assumed that Test implements the correct methods to
+         *  support the event handler interfaces.  So to use them, first
+         *  make a new cartridge
+         */
+        EventCartridge ec = new EventCartridge();
+
+        /*
+         * then register this class as it contains the handlers
+         */
+        ec.addEventHandler(this);
+
+        /*
+         * and then finally let it attach itself to the context
+         */
+        ec.attachToContext( context );
+
+        /*
+         * now merge your template with the context as you normally
+         * do
+         */
+
+        ....
+    }
+
+    /*
+     *  and now the implementations of the event handlers
+     */
+    public Object referenceInsert( String reference, Object value  )
+    {
+        /*  do something with it */
+        return value;
+    }
+
+    public boolean shouldLogOnNullSet( String lhs, String rhs )
+    {
+        if ( /* whatever rule */ )
+            return false;
+
+        return true;
+    }
+
+    public Object methodException( Class claz, String method, Exception e )
+         throws Exception
+    {
+        if ( /* whatever rule */ )
+           return &quot;I should have thrown&quot;;
+
+        throw e;
+    }
+}
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Velocity Configuration Keys and Values"><strong>Velocity Configuration Keys and Values</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+Velocity's runtime configuration is controlled by a set of configuration keys
+listed below.  Generally, these keys will have values that consist of either a
+String, or a comma-separated list of Strings, referred to as a CSV for
+comma-separated values.
+</p>
+                                                <p>
+There is a set of default values contained in Velocity's jar, found in
+/src/java/org/apache/velocity/runtime/defaults/velocity.defaults, that
+Velocity uses as it's configuration baseline.
+This ensures that Velocity will always have a 'correct' value
+for it's configuration keys at startup, although it may not be what you want.
+</p>
+                                                <p>
+Any values specified before init() time will replace the  default values.
+Therefore, you only have toconfigure velocity with the values for the keys
+that you need to change, and not worry about the rest.  Further, as we add more
+features and configuration capability, you don't have to change your
+configuration files to suit - the Velocity engine will always have default
+values.
+</p>
+                                                <p>
+Please sees the section above <a href="developer-guide.html#Using Velocity In General Applications"><b>Using Velocity In General
+Applications</b></a> for discussion on the configuration API.
+</p>
+                                                <p>
+Below are listed the configuration keys that control Velocity's behavior.
+Organized by category, each key is listed with it's current default value
+to the right of the '=' sign.
+</p>
+                                                <p>
+<strong>Runtime Log</strong>
+</p>
+                                                <p>
+<code>runtime.log = velocity.log</code><br />
+Full path and name of log file for error, warning,
+and informational messages.  The location, if not absolute, is
+relative to the 'current directory'.
+</p>
+                                                <p>
+<code>runtime.log.logsystem</code><br />
+This property has no default value.  It is used to give Velocity an
+instantiated instance of a logging class that supports the interface
+<code>org.apache.velocity.runtime.log.LogSystem.</code>, which allows
+the combination of Velocity log messages with your other application
+log messages.  Please see the section
+<a href="developer-guide.html#Configuring the Log System">Configuring the Log System</a>
+for more information.
+</p>
+                                                <p>
+<code>runtime.log.logsystem.class =
+org.apache.velocity.runtime.log.AvalonLogSystem</code><br />
+Class to be used for the Velocity-instantiated log system.
+</p>
+                                                <p>
+<code>runtime.log.error.stacktrace = false</code><br />
+<code>runtime.log.warn.stacktrace = false</code><br />
+<code>runtime.log.info.stacktrace = false</code><br />
+Turns on stacktracing for the three error categories.
+These produce a large amount of log output.
+</p>
+                                                <p>
+<code>runtime.log.invalid.references = true </code><br />
+Property to turn off the log output when a reference isn't valid.
+Good thing to turn of in production, but very valuable
+for debugging.
+</p>
+                                                <p>
+<code>runtime.log.logsystem.avalon.logger = <i>name</i> </code><br />
+Allows user to specify an existing logger <i>name</i>
+in the Avalon hierarchy
+without having to wrap with a LogSystem interface.  <b>Note:</b>
+You must also specify
+<code>runtime.log.logsystem.class =
+org.apache.velocity.runtime.log.AvalonLogSystem</code> as the default
+logsystem may change.  There is <b>no</b> guarantee that the Avalon
+log system will remain the default log system.
+</p>
+                                                <p>
+<strong>Character Encoding</strong>
+</p>
+                                                <p>
+<code>input.encoding = ISO-8859-1</code><br />
+Character encoding for input (templates).  Using this, you can use
+alternative encoding for your templates, such as UTF-8.
+</p>
+                                                <p>
+<code>output.encoding = ISO-8859-1</code><br />
+Character encoding for output streams from the VelocityServlet and Anakia.
+</p>
+                                                <p>
+<strong>#foreach() Directive</strong>
+</p>
+                                                <p>
+<code>directive.foreach.counter.name = velocityCount</code><br />
+Used in the #foreach() directive, defines the string to be used as the
+context key for the loop count. A template would access
+the loop count as $velocityCount.
+</p>
+                                                <p>
+<code>directive.foreach.counter.initial.value = 1</code><br />
+Default starting value for the loop counter reference in a #foreach() loop.
+</p>
+                                                <p>
+<strong>#include() and #parse() Directive</strong>
+</p>
+                                                <p>
+<code>directive.include.output.errormsg.start
+= <![CDATA[ <!-- include error : ]]> </code><br />
+<code>directive.include.output.errormsg.end
+=  <![CDATA[ see error log --> ]]></code><br />
+Defines the beginning and ending tags for an in-stream error message in the
+case of a problem with the #include() directive. If both the .start and .end
+tags are defined, an error message will be output to the stream, of the
+form '.start msg .end' where .start and .end refer to the property values.
+Output to the render stream will only occur if both the .start and .end
+(next) tag are defined.
+</p>
+                                                <p>
+<code>directive.parse.maxdepth = 10</code><br />
+Defines the allowable parse depth for a template. A template may #parse()
+another template which itself may have a #parse() directive.  This value
+prevents runaway #parse() recursion.
+</p>
+                                                <p>
+<strong>Resource Management</strong>
+</p>
+                                                <p>
+<code>resource.manager.logwhenfound = true</code><br />
+Switch to control logging of 'found' messages from resource manager.
+When a resource is found for the first time, the resource name
+and classname of the loader that found it will be noted in the
+runtime log.
+</p>
+                                                <p>
+<code>resource.loader = &lt;name&gt; (default = File)</code><br />
+<i>Multi-valued key.  Will accept CSV for value.</i>  Pulic name of a
+resource loader to be used.  This public name will then be used
+in the specification of the specific properties for that resource loader.
+Note that as a multi-valued key, it's possible to pass
+a value like "file, class" (sans quotes), indicating that following
+will be configuration values for two loaders.
+</p>
+                                                <p>
+<code>&lt;name&gt;.loader.description
+= Velocity File Resource Loader</code><br />
+Description string for the given loader.
+</p>
+                                                <p>
+<code>&lt;name&gt;.resource.loader.class
+= org.apache.velocity.runtime.resource.loader.FileResourceLoader</code><br />
+Name of implementation class for the loader.  The default loader
+is the file loader.
+</p>
+                                                <p>
+<code>&lt;name&gt;.resource.loader.path = .</code><br />
+<i>Multi-valued key.  Will accept CSV for value.</i> Root(s) from which the
+loader loads templates. Templates may live in  subdirectories of this root.
+ex. homesite/index.vm   This configuration key applies currently to the
+FileResourceLoader and JarResourceLoader.
+</p>
+                                                <p>
+<code>&lt;name&gt;.resource.loader.cache = false</code><br />
+Controls caching of the templates in the loader.  Default is false, to make
+life easy for development and debugging.  This should be set to true for
+production deployment.  When 'true', the <code>modificationCheckInterval</code>
+property applies.  This allows for the efficiency of caching, with the
+convenience of controlled reloads - useful in a hosted or ISP environment
+where templates can be modifed frequently and bouncing the application or
+servlet engine is not desired or permitted.
+</p>
+                                                <p>
+<code>&lt;name&gt;.resource.loader.modificationCheckInterval = 2</code><br />
+This is the number of seconds between modification checks when caching is
+turned on.  When this is an integer &gt; 0, this represents the number of
+seconds between checks to see if the template was modified.  If the
+template has been modified since last check, then it is reloaded and
+reparsed.  Otherwise nothing is done.  When &lt;= 0, no modification
+checks will take place, and assuming that the property <code>cache</code>
+(above) is true, once a template is loaded and parsed the first time it is used,
+it will not be checked or reloaded after that until the application or
+servlet engine is restarted.
+</p>
+                                                <p> To illustrate, here is an example taken right from the default Velocity
+properties, showing how setting up the FileResourceLoader is managed
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+resource.loader = file
+
+file.resource.loader.description = Velocity File Resource Loader
+file.resource.loader.class = 
+   org.apache.velocity.runtime.resource.loader.FileResourceLoader
+file.resource.loader.path = .
+file.resource.loader.cache = false
+file.resource.loader.modificationCheckInterval = 2
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+<strong>Velocimacro</strong>
+</p>
+                                                <p>
+<code>velocimacro.library = VM_global_library.vm </code><br />
+<i>Multi-valued key.  Will accept CSV for value.</i>
+Filename(s) of Velocimacro library to be loaded when the Velocity
+Runtime engine starts.  These Velocimacros are accessable to all
+templates.  The file is assumed to be relative to the root of the
+file loader resource path.
+</p>
+                                                <p>
+<code>velocimacro.permissions.allow.inline = true</code><br />
+Determines of the definition of new Velocimacros via the #macro() directive
+in templates is allowed.   The default value is true, meaning any template
+can define and use new Velocimacros.  Note that depending on other properties,
+those #macro() statements can replace global definitions.
+</p>
+                                                <p>
+<code>velocimacro.permissions.allow.inline.to.replace.global = false </code><br />
+Controls if a Velocimacro defind 'inline' in a template can replace
+a Velocimacro defined in a library loaded at startup.
+</p>
+                                                <p>
+<code>velocimacro.permissions.allow.inline.local.scope = false</code><br />
+Controls 'private' templates namespaces for Velocimacros.  When true, a #macro()
+directive in a template  creates a Velocimacro that is accessable only from the
+defining template.  This means that Velocimacros cannot be shared unless they
+are in the global or local library loaded at startup. (See above.)  It also means
+that templates cannot interfere with each other.  This property also allows a technique
+where there is a 'default' Velocimacro definition in the global or local library,
+and a template can 'override' the implementation for use within that template.
+This occurrs because when this property is true, the template's namespace is
+searched for a Velocimacro before the global namespace, therefore allowing
+the override mechanism.
+</p>
+                                                <p>
+<code>velocimacro.context.localscope = false</code><br />
+Controls whether reference access (set/get) within a Velocimacro will change
+the context, or be of local scope in that
+Velocimacro.
+</p>
+                                                <p>
+<code>velocimacro.library.autoreload = false</code><br />
+Controls Velocimacro library autoloading.  When set to <code>true</code>
+the source Velocimacro library for an invoked Velocimacro will be checked
+for changes, and reloaded if necessary.  This allows you to change and
+test Velocimacro libraries without having to restart your application or
+servlet container, just like you can with regular templates.
+This mode only works when caching is <i>off</i>
+in the resource loaders (e.g. <code>file.resource.loader.cache = false</code> ).
+This feature is intended for development, not for production.
+</p>
+                                                <p>
+<strong>String Interpolation</strong>
+</p>
+                                                <p>
+<code>runtime.interpolate.string.literals = true</code><br />
+Controls interpolation mechanism of VTL String Literals.  Note that a VTL
+StringLiteral is specifically a string using double quotes that is used
+in a #set() statement, a method call of a reference, a parameter to a VM,
+or as an argument to a VTL directive in general.  See the VTL reference for
+further information.
+</p>
+                                                <p>
+<strong>Runtime Configuration</strong>
+</p>
+                                                <p>
+<code>parser.pool.size = 20</code><br />
+This property sets the number of parsers that Velocity will
+create at startup and keep in a pool.  The default of 20 parsers
+should be more than enough for most uses.  In the event
+that Velocity does run out of parsers, it will indicate
+so in the log, and
+dynamically create them as needed.  Note that they will not
+be added to the pool.  This is a slow operation compared to
+the normal parser pooling, but this is considered an
+exceptional condition.  If you see a log message, please
+increment this property.
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Configuring the Log System"><strong>Configuring the Log System</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+Velocity has a few nice logging features to allow both simplicity and
+flexibility. Without any extra configuration, Velocity will setup a
+file-based logger that will output all logging messages to a file
+called <code>velocity.log</code> in the 'current directory' where
+Velocity was initialized.   For more advanced users, you may integrate
+your current logging facilities with Velocity to have all log messages
+sent to your logger.
+</p>
+                                                <p>
+Starting with version 1.3, Velocity will automatically use either the
+<a href="http://jakarta.apache.org/avalon/logkit/index.html">
+Jakarta Avalon Logkit</a> logger, or the
+<a href="http://jakarta.apache.org/log4j/">Jakarta Log4j</a> logger.
+It will do so by using whatever it finds in the current classpath, starting
+first with Logkit.  If Logkit isn't found, it tries Log4j.
+</p>
+                                                <p>
+To utilize this feature, simply use the 'non-dependency' Velocity jar
+(because Logkit is baked into the jar with dependencies) and place
+either the logkit or log4j jar in your classpath.
+</p>
+                                                <p>
+In general, you have the following logging options :
+</p>
+                                                <ul>
+
+<li>
+<b>Default Configuration</b><br />
+By default, Velocity will create a file-based logger in the current
+directory.  See the note above regarding automatic detection of
+Logkit or Log4j to use as the default logging system.
+</li>
+
+<li>
+<b>Existing Log4j Category</b><br />
+Starting with version 1.3, Velocity will log it's output to an existing
+Log4j Category setup elsewhere in the application.  To use this feature
+you must
+  <ol>
+    <li>
+    Make sure that the Log4j jar is in your classpath. (You would do this
+    anyway since you are using Log4j in the application using Velocity.)
+    </li>
+    <li>
+    Configure Velocity to use the <code>SimpleLog4jLogSystem</code> class.
+    </li>
+    <li>
+    Specify the name of the existing Category to use via the
+    'runtime.log.logsystem.log4j.category' property.
+    </li>
+  </ol>
+
+This approach replaces and deprecates the older <code>Log4JLogSystem</code>
+class.  To see how this is done in code, see the example below.
+</li>
+
+<li>
+<b>Custom Standalone Logger</b><br />
+You can create a custom logging class - you simply must implement the
+interface  <code>org.apache.velocity.runtime.log.LogSystem</code> and
+then simply set the  configuration property
+<code>runtime.log.logsystem.class</code> with the
+classname, and Velocity will create an instance of that class at init time.
+You may specify the classname as you specify any other properties. See
+the information on the
+<a href="developer-guide.html#Using Velocity In General Applications">
+Velocity helper class</a> as well as the
+<a href="developer-guide.html#Velocity Configuration Keys and Values">
+configuration keys and values.</a>
+Please note that through oversight, the interface to
+<code>org.apache.velocity.runtime.log.LogSystem</code>
+was changed in v1.2 to support the separable instances of the Velocity
+runtime.  If you have an exisiting pre v1.2 custom logger that is going
+to be instantiated by the Velocity LogManager, you must add the
+<code>init( RuntimeServices )</code> method.
+</li>
+
+<li>
+<b>Integrated Logging</b><br />
+You can integrate Velocity's logging capabilities with your applications
+existing logging system, simply by implementing the
+<code>org.apache.velocity.runtime.log.LogSystem</code> interface.  Then,
+pass an instance of your logging class to Velocity via the
+<code>runtime.log.logsystem</code> configuration key before
+initializing the Velocity engine,
+and Velocity will log messages to your applications logger.
+See the information on the
+<a href="developer-guide.html#Using Velocity In General Applications">Velocity helper class</a>
+as well as the
+<a href="developer-guide.html#Velocity Configuration Keys and Values">configuration keys and values.</a>
+</li>
+
+</ul>
+                                                <a name="Using Log4j With Existing Category"><strong>Using Log4j With Existing Category</strong></a>
+                                                <p>
+Here is an example of how to configure Velocity to log to an existing Log4j
+Category.
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+import org.apache.velocity.app.VelocityEngine;
+import org.apache.velocity.runtime.RuntimeConstants;
+
+import org.apache.log4j.Category;
+import org.apache.log4j.BasicConfigurator;
+
+public class Log4jCategoryExample
+{
+    public static String CATEGORY_NAME = &quot;velexample&quot;;
+
+    public static void main( String args[] )
+        throws Exception
+    {
+        /*
+         *  configure log4j to log to console
+         */
+
+        BasicConfigurator.configure();
+
+        Category log = Category.getInstance( CATEGORY_NAME );
+
+        log.info(&quot;Hello from Log4jCategoryExample - ready to start velocity&quot;);
+
+        /*
+         *  now create a new VelocityEngine instance, and
+         *  configure it to use the category
+         */
+
+        VelocityEngine ve = new VelocityEngine();
+
+        ve.setProperty( RuntimeConstants.RUNTIME_LOG_LOGSYSTEM_CLASS,
+            &quot;org.apache.velocity.runtime.log.SimpleLog4JLogSystem&quot; );
+
+        ve.setProperty(&quot;runtime.log.logsystem.log4j.category&quot;, CATEGORY_NAME);
+
+        ve.init();
+
+        log.info(&quot;this should follow the initialization output from velocity&quot;);
+    }
+}
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+Note that the above example can be found in <code>examples/logger_example</code>.
+</p>
+                                                <a name="Simple Example of a Custom Logger"><strong>Simple Example of a Custom Logger</strong></a>
+                                                <p>
+Here is an example of how to use an instantiation of your class that implements
+Velocity's logging system as the logger.  Note that we are not passing the name
+of the class to use, but rather a living, existing instantiation of the class
+to be used.  All that is required is that it support the
+<code>LogSystem</code> interface.
+
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+import org.apache.velocity.runtime.log.LogSystem;
+import org.apache.velocity.runtime.RuntimeServices;
+...
+
+public class MyClass implements LogSystem
+{
+
+...
+
+    public MyClass()
+    {
+        ...
+
+        try
+        {
+            /*
+             *  register this class as a logger
+             */
+            Velocity.setProperty(Velocity.RUNTIME_LOG_LOGSYSTEM, this );
+            Velocity.init();
+        }
+        catch (Exception e)
+        {
+            /*
+             *  do something
+             */
+        }
+    }
+
+    /**
+     *  This init() will be invoked once by the LogManager
+     *  to give you current RuntimeServices intance
+     */
+    public void init( RuntimeServices rsvc )
+    {
+        // do nothing
+    }
+
+    /**
+     *  This is the method that you implement for Velocity to call
+     *  with log messages.
+     */
+    public void logVelocityMessage(int level, String message)
+    {
+        /*  do something useful */
+    }
+...
+}
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Configuring Resource Loaders"><strong>Configuring Resource Loaders</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <a name="Resource Loaders"><strong>Resource Loaders</strong></a>
+                                                <p>
+One of the fundamental and important parts about Velocity is the resource
+management system and the resource loaders.  They are referred to as 'resources'
+here rather than 'templates' because the resource management system will also
+handle non-template reasources, specifically things that are loaded via the
+#include() directive.
+</p>
+                                                <p>
+The resource loader system if very flexible, allowing one or more resource
+loaders to be in operation at the same time.  This allows tremendous
+flexibility in configuration and resource managment, and futher allows you
+to write your own resource loaders for your special needs.
+</p>
+                                                <p>
+There are currently four kinds of resource loaders that are included with Velocity,
+each described below.  Note that in the example configuration properties given,
+a common name for the loader is shown
+(ex.'file' in <code>file.resource.loader.path</code>). This 'common name'
+may not work for your configuration. Please read the section on
+<a href="developer-guide.html#Velocity Configuration Keys and Values">resource configuration properties</a>
+ to understand how this system works.  Also, each of these loaders is
+located in the package <code>org.apache.velocity.runtime.resource.loader</code>.
+</p>
+                                                <ul>
+<li>
+  <b>FileResourceLoader :</b> This loader gets resources from the filesystem. It's
+  configuration properties include :
+  <ul>
+    <li>
+      <code>file.resource.loader.path</code> = &lt;path to root of templates&gt;
+    </li>
+    <li>
+      <code>file.resource.loader.cache</code> = true/false
+    </li>
+    <li>
+      <code>file.resource.loader.modificationCheckInterval</code> = &lt;seconds between checks&gt;
+    </li>
+  </ul>
+  This is the default loader, and is configured, by default to get templates from the
+  'current directory'.  In the case of using Velocity with servlets, this can be a problem
+  as you don't want to have to keep your templates in the directory from which you start
+  your servlet engine.  Please see the section on
+  <a href="developer-guide.html#Using Velocity In Servlets"> developing servlets with Velocity</a>
+   for more information.
+</li>
+<li>
+  <b>JarResourceLoader :</b> This loader gets resource from specific jar files.  It is very
+  similar to the FileResourceLoader, except that you have the convenience of bundling
+  your templates into jars.  The properties are identical, except for
+  <code>jar.resource.loader.path</code>, where you provide the full location of
+  the jar(s) you wish to load resources from.  To specify a jar for the loader.path
+  you use the standard JAR URL syntax of <code>java.net.JarURLConnection</code>.
+</li>
+<li>
+  <b>ClasspathResourceLoader :</b> This loader gets resources from the classloader.
+  In general, this means that the ClasspathResourceLoader will load
+  templates placed in the classpath (in jars, for example)
+  While the
+  classpath is a source of great pain and suffering in general, it is a very useful
+  mechanism when working on a Servlet Spec 2.2 (or newer) compliant servlet runner.
+  <a href="http://jakarta.apache.org/tomcat/">Tomcat</a>
+  is an example of such.  To use this loader effectively, all you must do is
+  jar your templates, and put that jar into the WEB-INF/lib directory of your
+  webapp.  There are no configuration options to worry about, nor is the absolute vs.
+  relative path an issue, as it is with Jar and File resource loaders.
+  Again, please note that the ClasspathResourceLoader is not only for use with a
+  servlet container, but can be used in any application context.
+</li>
+
+<li>
+  <b>DataSourceResourceLoader :</b>  This loader will load resources from a DataSource
+such as a database.  This loader is not built as part of the standard build
+as it requires J2EE support.  To build this loader, please download the J2EE
+distribution, move the j2ee.jar into the <code>build/lib</code> directory,
+and then build the new velocity jar with the <code>jar-j2ee</code> build target.
+For more information on this loader, please see the javadoc for the class
+<code>org.apache.velocity.runtime.resource.loader.DataSourceResourceLoader</code>.
+</li>
+
+</ul>
+                                                <a name="Configuration Examples"><strong>Configuration Examples</strong></a>
+                                                <p>
+Configuring the resource loaders for Velocity is straightforward.
+The properties that control the are listed in the
+<a href="developer-guide.html#Configuring Resource Loaders">resource configuration</a>
+section, for further reference.
+</p>
+                                                <p>
+The first step in configuring one or more resource loaders is do
+'declare' them by name to Velocity.  Use the property
+<code>resource.loader</code> and list one or more loader names.
+You can use anything you want - these names are used to associate
+configuration properties with a given loader.
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+resource.loader = file
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+That entry declares that we will have a resource loader known as 'file'.
+The next thing to do is to set the important properties.  The most critical
+is to declare the class to use as the loader :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+file.resource.loader.class = 
+   org.apache.velocity.runtime.resource.loader.FileResourceLoader
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+In this case, we are telling velocity that we are setting up
+a resource loadercalled 'file', and are using the class
+<code>
+org.apache.velocity.runtime.resource.loader.FileResourceLoader
+</code>
+to be the class to use.
+The next thing we do is set the properties important
+to this loader.
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+file.resource.loader.path = /opt/templates
+file.resource.loader.cache = true
+file.resource.loader.modificationCheckInterval = 2
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+Here, we set a few things.  First, we set the path to find
+the templates to be <code>/opt/templates</code>.  Second, we
+turned caching on, so that after a template or static file
+is read in, it is cached in memory.  And finally, we set
+the modification check interval to 2 seconds, allowing Velocity
+to check for new templates.
+</p>
+                                                <p>
+Those are the basics.  What follows are a few examples of different configuraitons.
+</p>
+                                                <p>
+<b>Do-nothing Default Configuration : </b> As the name says, there is nothing
+you have to do or configure to get the default configuration.  This configuration
+uses the FileResourceLoader with the current directory as the default resource
+path, and caching is off.  As a properties set, this is expressed as :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+resource.loader = file
+
+file.resource.loader.description = Velocity File Resource Loader
+file.resource.loader.class = 
+   org.apache.velocity.runtime.resource.loader.FileResourceLoader
+file.resource.loader.path = .
+file.resource.loader.cache = false
+file.resource.loader.modificationCheckInterval = 0
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+<b>Multiple Template Path Configuration : </b> This configuration
+uses the FileResourceLoader with several directories as 'nodes' on the
+template search path. We also want to use caching, and have the templates
+checked for changes in 10 second intervals.  As a properties set, this is expressed as :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+resource.loader = file
+
+file.resource.loader.description = Velocity File Resource Loader
+file.resource.loader.class = 
+   org.apache.velocity.runtime.resource.loader.FileResourceLoader
+file.resource.loader.path = /opt/directory1, /opt/directory2
+file.resource.loader.cache = true
+file.resource.loader.modificationCheckInterval = 10
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+<b>Multiple Loader Configuration :</b>  This configuration sets up
+three loaders at the same time, the FileResourceLoader,
+the ClasspathResourceLoader, and the JarResourceLoader.
+ The loaders are set-up such that the
+FileResourceLoader is consulted first, then the
+ClasspathResourceLoader, and finally the JarResourceLoader.
+This would allow you to qickly
+drop a template into the file template area to replace on of the
+templates found in the classpath (usually via a jar) without
+having to rebuild the jar.
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+#
+# specify three resource loaders to use
+#
+resource.loader = file, class, jar
+
+#
+# for the loader we call 'file', set the FileResourceLoader as the
+# class to use, turn off caching, and use 3 directories for templates
+#
+file.resource.loader.description = Velocity File Resource Loader
+file.resource.loader.class = 
+   org.apache.velocity.runtime.resource.loader.FileResourceLoader
+file.resource.loader.path = templatedirectory1, anotherdirectory, foo/bar
+file.resource.loader.cache = false
+file.resource.loader.modificationCheckInterval = 0
+
+#
+#  for the loader we call 'class', use the ClasspathResourceLoader
+#
+class.resource.loader.description = Velocity Classpath Resource Loader
+class.resource.loader.class = 
+   org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader
+
+#
+# and finally, for the loader we call 'jar', use the JarResourceLoader
+# and specify two jars to load from
+#
+jar.resource.loader.description = Velocity Jar  Resource Loader
+jar.resource.loader.class = 
+   org.apache.velocity.runtime.resource.loader.JarResourceLoader
+jar.resource.loader.path = 
+   jar:file:/myjarplace/myjar.jar, jar:file:/myjarplace/myjar2.jar
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+Node that the three names 'file', 'class', and 'jar' are merely for your convenience and
+sanity.  They can be anything you want - they are just used to associate a set of
+properties together.  However, it is recommended that you use names that give some hint
+of the function.
+</p>
+                                                <p>
+Note that while all three require very little configuration information
+for proper operation, the ClasspathResourceLoader is the simplest.
+</p>
+                                                <a name="Resource Manager and Cache" />
+                                                <strong>Pluggable Resource Manager and Resource Cache</strong>
+                                                <p>
+The Resource Manager is the main part of the resource (template and static content)
+management system, and is responsible for taking application requests for
+templates, finding them in the available resource loaders, and then optionally
+caching the parsed template.  The Resource Cache is the mechanism that the
+Resource Manager uses to cache templates for quick reuse. While the default
+versions of these two facilities are suitable for most
+applications, for advanced users  it now is possible
+to replace the default resource manager
+and resource cache with custom implementations.
+</p>
+                                                <p>
+A resource manager implementation must implement the
+<code>org.apache.velocity.runtime.resource.ResourceManager</code> interface.
+A description of the requirements of a resource manager is out of scope for
+this document.  Implementors are encouraged to review the default implementation.
+To configure Velocity to load the replacement implementation, use the
+configuration key :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+resource.manager.class
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+This key is also defined as a contstant
+<code>RuntimeConstants.RESOURCE_MANAGER_CLASS</code>
+</p>
+                                                <p>
+A resource cache implementation must implement the
+<code>org.apache.velocity.runtime.resource.ResourceCache</code> interface
+As with the resource manager, a description of the requirements of a
+resource manager is out of scope for
+this document.  Implementors are encouraged to review the default implementation.
+To configure Velocity to load the replacement implementation, use the
+configuration key :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+resource.manager.cache.class
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+This key is also defined as a contstant
+<code>RuntimeConstants.RESOURCE_MANAGER_CACHE_CLASS</code>
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Template Encoding for Internationalization"><strong>Template Encoding for Internationalization</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+As of version 1.1, Velocity allows you to specify the character encoding of your
+template resources on a template by template basis.  The normal resource
+API's have been extended to take the encoding as an argument :
+</p>
+                                                <p>
+<code>org.apache.velocity.servlet.VelocityServlet</code> : <br />
+<blockquote>
+  <i><code> public Template getTemplate( String template, String encoding )</code></i>
+</blockquote>
+</p>
+                                                <p>
+<code>org.apache.velocity.app.Velocity</code> : <br />
+<blockquote>
+  <i><code>public static Template getTemplate(String name, String encoding)</code></i>
+  <br />
+  <br />
+  <i><code>public static boolean mergeTemplate( String templateName, String encoding, Context context, Writer writer )</code></i>
+  <br />
+  <i><code> </code></i>
+</blockquote>
+</p>
+                                                <p>
+The value for the <i>encoding</i> argument is the conventional encoding specification
+supported by your JVM, for example "UTF-8" or "ISO-8859-1".  For the official names
+for character sets, see <a href="http://www.iana.org/assignments/character-sets">here</a>.
+</p>
+                                                <p>
+Note that this applies only to the encoding of the template itself - the output
+encoding is an application specific issue.
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Velocity and XML"><strong>Velocity and XML</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+Velocity's flexibility and simple template language makes it an ideal environment
+for working with XML data.  <a href="anakia.html">Anakia</a> is an example of how
+Velocity is used to replace XSL for rendering output from XML.  The Velocity site,
+including this documentation, is generated from XML source using Anakia.
+The Jakarta site is also rendered using Anakia.
+</p>
+                                                <p>
+Generally, the pattern for dealing with XML in Velocity is to use something like
+<a href="http://www.jdom.org/">JDOM</a> to process your XML into a data structure with
+convenient Java access.  Then, you produce templates that access data directly
+out of the XML document - directly though the JDOM tree.  For example, start
+with an XML document such as :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+&lt;?xml version=&quot;1.0&quot;?&gt;
+
+&lt;document&gt;
+ &lt;properties&gt;
+  &lt;title&gt;Developer's Guide&lt;/title&gt;
+  &lt;author email=&quot;geirm@apache.org&quot;&gt;Velocity Documentation Team&lt;/author&gt;
+ &lt;/properties&gt;
+&lt;/document&gt;
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+Now make a little Java program that includes code similar to:
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+...
+
+SAXBuilder builder;
+Document root = null;
+
+try
+{
+    builder = new SAXBuilder(  &quot;org.apache.xerces.parsers.SAXParser&quot; );
+    root = builder.build(&quot;test.xml&quot;);
+}
+catch( Exception ee)
+{}
+
+VelocityContext vc = new VelocityContext();
+vc.put(&quot;root&quot;, root );
+
+...
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+(See the Anakia source for details on how to do this, or the Anakia
+example in the <code>examples</code> directory in the distribution.)
+Now, make a regular Velocity template :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+&lt;html&gt;
+  &lt;body&gt;
+    The document title is
+    $root.getChild(&quot;document&quot;).getChild(&quot;properties&quot;).getChild(&quot;title&quot;).getText()
+  &lt;/body&gt;
+&lt;/html&gt;
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+and render that template as you normally would, using the Context
+containing the JDOM tree. Of course, this isn't the prettiest of
+examples, but it shows the basics - that you can easily access XML data
+directly from a Velocity template.
+</p>
+                                                <p>
+One real advantage of styling XML data in Velocity is that you have
+access to any other object or data that the application provides.  You
+aren't limited to just using the data present in the XML document.
+You may add anything you want to the context to provide additional
+information for your output, or provide tools to help make working
+with the XML data easier.  Bob McWhirter's
+<a href="http://sourceforge.net/projects/werken-xpath/"> Werken Xpath</a>
+is one such useful tool - an example of how it is used in Anakia can be
+found in <code>org.apache.velocity.anakia.XPathTool</code>.
+</p>
+                                                <p>
+One issue that arises with XML and Velocity is how to deal with XML
+entities. One technique is to combine the use of Velocimacros
+when you need to render an entity into the output stream :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+## first, define the Velocimacro somewhere
+
+#macro( xenc $sometext )$tools.escapeEntities($sometext)#end
+
+## and use it as
+
+#set( $sometext = &quot; &lt; &quot; )
+&lt;text&gt;#xenc($sometext)&lt;/text&gt;
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+where the escapeEntities() is a method that does the escaping
+for you. Another trick would be to create an encoding utility that takes the
+context as a constructor parameter and only implements a method:
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+public String get(String key)
+{
+    Object obj = context.get(key)
+    return (obj != null) ? Escape.getText( obj.toString() ) : &quot;&quot;;
+}
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+Put it into the context as "xenc". Then you can use it as :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+&lt;text&gt;$xenc.sometext&lt;/text&gt;
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+This takes advantage of Velocity's introspection process - it will try
+to call get("sometext") on the $xenc object in the Context - then the
+xenc object can then get the value from the Context, encode it, and
+return it.
+</p>
+                                                <p>
+Alternatively, since Velocity makes it easy to implement custom Context
+objects, you could implement your own context which always applies the
+encoding to any string returned. Be careful to avoid rendering the
+output of method calls directly, as they could return objects or strings
+(which might need encoding). Place them first into the context with a
+#set() directive and the use that, for example :
+</p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+#set( $sometext = $jdomElement.getText() )
+&lt;text&gt;$sometext&lt;/text&gt;
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+The previous suggestions for dealing with XML entities came from
+Christoph Reck, an active participant in the Velocity community.  We are
+very grateful for his [unknowing] contribution to this document, and
+hope his ideas weren't mangled too badly  :)
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="FAQ (Frequently Asked Questions)"><strong>FAQ (Frequently Asked Questions)</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+In no apparent order, here are questions and answers that repeatedly arise
+by developers using Velocity.  As we get more, we will move this out to
+a separate document.
+</p>
+                                                <strong>Why Can't I Access Class Members and Constants from VTL?</strong>
+                                                <p>
+ The short answer is because we don't introspect for fields.  We don't do that
+ because we wish to promote the idea that you hide your raw data in your
+ data objects.  There are two solutions to this issue.  The first is
+ that you should be writing accessors for data elements you wish to be
+ publicly exposed.  That of course won't work for instances where you don't
+ have the source, or simply are too lazy.  There is a class for the latter
+ group, <code>org.apache.velocity.app.FieldMethodizer</code> which introspects
+ your class, and exposes the public static fields in a way that allows easy
+ access from a template. Suppose you have a class :
+ </p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+    public class Foo
+    {
+        public static String PATH_ROOT = &quot;/foo/bar&quot;;
+
+        ....
+    }
+  </pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+  Then, in your code, you would put a <code>Foo</code> into the context like this
+  </p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+      context.put(&quot;myfoo&quot;, new FieldMethodizer( new Foo() ) );
+  </pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+     Then to access this field in your template, you would simply access in
+     a manner similar to Java :
+   </p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+       $myfoo.PATH_ROOT
+  </pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+     If you have a crushing need to access public non-static members (or even private
+     if you are so driven), then you would have to exend / modify the
+     <code>FieldMethodizer</code> yourself. (And we still recommend you provide accessors....)
+  </p>
+                                                <strong>Where does Velocity look for Templates?</strong>
+                                                <p>
+    By default, without any configuration on your part, Velocity will look
+    for templates in files, and look for them in the current directory
+    (or relative to the current directory, if you prepend a path to your
+    template, like 'foo/bar.vm').
+   </p>
+                                                <p>
+     Velocity does this to make it as easy as possible to use out of the box.
+     It has been argued that Velocity should do it from the 'root' directory, but
+     it's never clear what that is on filesystems where there are multiple roots
+     (like - "C:\", "D:\", etc).
+    </p>
+                                                <p>
+      For more information, see the section on
+      <a href="developer-guide.html#Configuring Resource Loaders">
+      resource loaders</a> as well as the section on
+      <a href="developer-guide.html#Velocity Configuration Keys and Values">
+      configuration keys, values and defaults</a>.
+     </p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Summary"><strong>Summary</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+We hope this brief guide was a helpful introduction to using Velocity in
+your Java projects, and thank you for you interest in Velocity.  We
+welcome any and all comments you may have about this documentation and
+the Velocity template engine itself.
+</p>
+                                                <p>
+Please submit all detailed, thoughtful and constructive feedback through our
+<a href="http://jakarta.apache.org/getinvolved/mail.html">mail lists</a>.
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Appendix 1 : Deploying the Example Servlet"><strong>Appendix 1 : Deploying the Example Servlet</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+A continuing source of frustration for beginning servlet users is getting
+all the pieces into place and working.  Using a servlet engine like Tomcat or Resin
+is far from obvious for the first time user (and even for more experienced users...).
+The following are the basic instructions, to the best of our knowledge, for getting
+the SampleServlet example working. Note that the sample template <code>sample.vm</code>
+and the servlet code itself, <code>SampleServlet.java</code> are
+ found in the <code>examples/servlet_example</code> directory.  Although some servlet
+engines (Resin, for example) will compile the servlet for you, it would be best if
+you compiled the examples first.  To do this, see the section on building Velocity, and
+use the <code>examples</code> target.
+</p>
+                                                <p>
+<a name="TomcatExample"><strong>Jakarta Tomcat</strong></a>
+</p>
+                                                <p>
+Setting up under <a href="http://jakarta.apache.org/tomcat/">Jakarta Tomcat</a> is fairly
+straightforward.  The 'webapp' directory is where Tomcat automatically
+looks for it's 'web applications', so
+this is where we will set things up.
+</p>
+                                                <ol>
+<li> First, make a new 'webapp'  by creating a directory called <i>velexample</i>
+ in Tomcat's webapps directory, and make
+ a new directory structure as follows :
+   <blockquote>
+      velexample<br />
+      velexample/WEB-INF<br />
+      velexample/WEB-INF/lib<br />
+      velexample/WEB-INF/classes<br />
+   </blockquote>
+</li>
+<li>
+ Put the Velocity jar into the velexample/WEB-INF/lib directory.  Note that with v1.2
+ and newer, you either have to either use the jar from the distribution (or that you
+ build yourself) that contains all the dependencies ( ex. velocity-dep-1.2.jar) or
+ you must add the dependency jars yourself to the WEB-INF/lib directory. Please see
+ the section "Getting Started" and "Dependencies", above.
+</li>
+<li>
+ Put the SampleServlet.class into the velexample/WEB-INF/classes directory
+</li>
+<li>
+ Put the sample.vm template into the velexample directory.  The SampleServlet is
+ written to use the root of the webapp as the source of the templates, so
+ no configuration is needed.
+</li>
+<li>
+ At this point, you should be able to start (or restart) Tomcat and access the servlet.
+</li>
+<li>
+To access the servlet, point your web browser at :
+
+<blockquote>
+http://localhost:8080/velexample/servlet/SampleServlet
+</blockquote>
+
+or if that doesn't work :
+
+<blockquote>
+    http://&lt;your computer's ip address&gt;:8080/velexample/servlet/SampleServlet
+</blockquote>
+</li>
+<li>
+ You should see the sample output.
+</li>
+</ol>
+                                                <p>
+<a name="ResinExample"><strong>Caucho Technology's Resin</strong></a>
+</p>
+                                                <p>
+Setting up the example servlet under <a href="http://www.caucho.com">Caucho Technology's Resin</a>
+servlet engine is also very simple.  The following instructions were tested with the version 1.2.5
+release.  The following assume that you have unzip-ed or untar-ed the distribution, know how to start
+the servlet engine (something like bin/httpd.sh under unix...), and know where the doc directory is
+(in the root of the distribution).
+</p>
+                                                <ol>
+<li>
+Copy the SampleServlet.class file into the doc/WEB-INF/classes directory.
+</li>
+<li>
+Copy the sample.vm template file into the doc/ directory
+</li>
+<li>
+Copy the Velocity jar (and any required dependencies - see note above in
+Tomcat setup section) into the doc/WEB-INF/lib directory.
+</li>
+<li>
+Start resin.
+</li>
+<li>
+To access the servlet, point your web browser at :
+
+<blockquote>
+http://localhost:8080/servlet/SampleServlet
+</blockquote>
+
+or if that doesn't work :
+
+<blockquote>
+    http://&lt;your computer's ip address&gt;:8080/servlet/SampleServlet
+</blockquote>
+
+and you should see the output.
+</li>
+</ol>
+                                                <p>
+Note that this appeared to be a simpler configuration - with the Tomcat example,
+you set up a complete, new, separate webapp, whereas the Resin instructions
+don't, although both should provide a sufficient setup to let you play with
+Velocity.
+</p>
+                                                <p>Note that while we wish we could, we can't answer questions about the servlet
+engines.  Please use the resources provided by the servlet engine provider.
+</p>
+                                                <p>
+<a name="WebLogic"><strong>BEA WebLogic</strong></a>
+</p>
+                                                <p>
+Paw Dybdahl &lt;pdy@csg.csc.dk&gt; contributed <a href="velocity_and_weblogic.html">this</a>
+description of using Velocity with WebLogic, as well as some good general suggestions and
+examples for working with servlets.
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                        </td>
+                </tr>
+
+                <!-- FOOTER -->
+                <tr><td colspan="2">
+                    <hr noshade="" size="1"/>
+                </td></tr>
+                <tr><td colspan="2">
+                    <div align="center"><font color="#525D76" size="-1"><em>
+                    Copyright &#169; 1999-2002, Apache Software Foundation
+                    </em></font></div>
+                </td></tr>
+            </table>
+        </body>
+    </html>
+<!-- end the processing -->
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/org.apache.click.eclipse/documentation/velocity/images/logo.gif b/org.apache.click.eclipse/documentation/velocity/images/logo.gif
new file mode 100644
index 0000000..a0abbda
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/velocity/images/logo.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/velocity/images/powered-by-logo.gif b/org.apache.click.eclipse/documentation/velocity/images/powered-by-logo.gif
new file mode 100644
index 0000000..0c5b050
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/velocity/images/powered-by-logo.gif
Binary files differ
diff --git a/org.apache.click.eclipse/documentation/velocity/velocity.html b/org.apache.click.eclipse/documentation/velocity/velocity.html
new file mode 100644
index 0000000..fe23263
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/velocity/velocity.html
@@ -0,0 +1,139 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<html>
+<head>
+ <link rel="stylesheet" type="text/css" href="../../help.css">
+</head>
+<body>
+<h1>Velocity</h1>
+Velocity is a Java-based template framework which provides the default HTML rending engine
+for Click. Velocity is very easy to learn, simple to use, and is also very capable.
+<p>
+<a href="http://velocity.apache.org/">Velocity</a> is an open source 
+Apache project licensed using the <a href="../LICENSE.txt">Apache</a> Software License.
+<p>
+Velocity's comprehensive online documentation is included in this distribution.
+<ul>
+  <li><a href="VelocityUsersGuide.pdf" target="blank">Users Guide</a> - Velocity users guide
+  </li>
+  <li><a href="developer-guide.html">Developers Guide</a> - Velocity developers configuration guide
+  </li>
+  <li><a href="vtl-reference-guide.html">VTL Reference</a> - Velocity Template Language (VTL) reference guide
+  </li>
+</ul>
+
+<p>&nbsp;</p>
+
+<h2>Object References</h2>
+With Click you add objects to your page template using the Page's model. You can then access these objects
+using Velocities <span class="red">$</span> reference notation. By default the ClickServlet adds the 
+following objects to page templates:
+<ul style="margin-bottom: 1.5em;">
+  <li>
+  any public Page fields using the fields name
+  </li>
+  <li><span class="st">context</span> &nbsp; - &nbsp;
+    the Servlet context path, e.g. <span class="blue">/mycorp</span>
+  </li>  
+  <li><span class="st">cssImports</span> &nbsp; - &nbsp; 
+    the CSS imports and style blocks to include in the pages header. 
+    Please see <a href="../click-api/org/apache/click/util/PageImports.html">PageImports</a> 
+    for more details.
+  </li>
+  <li><span class="st">format</span> &nbsp; - &nbsp; 
+    the <a href="../click-api/org/apache/click/util/Format.html">Format</a> 
+    object for formatting the display of objects.
+  </li>
+  <li><span class="st">imports</span> &nbsp; - &nbsp; 
+    the CSS and JavaScript imports to include in the pages header.
+    Please see <a href="../click-api/org/apache/click/util/PageImports.html">PageImports</a> 
+    for more details.
+  </li>
+  <li><span class="st">jsImports</span> &nbsp; - &nbsp; 
+    the JavaScript imports and script blocks to include in the pages footer. 
+    Please see <a href="../click-api/org/apache/click/util/PageImports.html">PageImports</a> 
+    for more details.
+  </li>
+  <li><span class="st">messages</span> &nbsp; - &nbsp; 
+   the <a target="topic" href="../click-api/org/apache/click/util/MessagesMap.html">MessagesMap</a> adaptor
+   for the Page <a href="../click-api/org/apache/click/Page.html#getMessage(java.lang.String)">getMessage()</a>
+   method.
+  </li>
+  <li><span class="st">path</span> &nbsp; - &nbsp; 
+    the <a href="../click-api/org/apache/click/Page.html#path">path</a> 
+    of the page template to render.
+  </li>
+  <li><span class="st">request</span> &nbsp; - &nbsp; 
+    the pages <a class="external" target="_blank" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpServletRequest.html">HttpServletRequest</a>
+    object.
+  </li>
+  <li><span class="st">response</span> &nbsp; - &nbsp; 
+    the pages <a class="external" target="_blank" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpServletResponse.html">HttpServletResponse</a>
+    object.
+  </li>
+  <li><span class="st">session</span> &nbsp; - &nbsp; 
+   the <a target="topic" href="../click-api/org/apache/click/util/SessionMap.html">SessionMap</a> adaptor
+   for the users <a class="external" target="_blank" href="http://java.sun.com/products/servlet/2.3/javadoc/javax/servlet/http/HttpSession.html">HttpSession</a>.
+  </li>
+</ul>
+
+In your page templates you can access object references using a dot path notation. For example:
+
+<pre class="codeHtml">
+Welcome: <span class="red">$</span><a target="topic" href="../click-api/org/apache/click/util/SessionMap.html">session</a>.user.fullName
+</pre>
+
+Or by using a more explicit Java notation:
+
+<pre class="codeHtml">
+Welcome: <span class="red">$</span><a target="topic" href="../click-api/org/apache/click/util/SessionMap.html">session</a>.get("user").getFullName()
+</pre>
+
+<h2>Directives</h2>
+In Velocity directives are prefixed by a <span class="red">#</span> symbol. While
+references access stuff, directives do stuff. The full set of Velocity directives are:
+
+<ul style="margin-bottom: 1.5em;"> 
+  <li><a href="vtl-reference-guide.html#if">#if #elseif #else</a> &nbsp; - &nbsp; 
+    output conditional on truth of statements.<p>
+  </li>
+  <li><a href="vtl-reference-guide.html#foreach">#foreach</a> &nbsp; - &nbsp; 
+     loops through a list of objects.<p>
+    <p>
+  </li>
+  <li><a href="vtl-reference-guide.html#macro">#macro</a> &nbsp; - &nbsp; 
+   allows users to define a Velocimacro (VM), a repeated segment of a VTL template, as required. <p>
+  </li>
+  <li><a href="vtl-reference-guide.html#set">#set</a> &nbsp; - &nbsp;
+   establishes the value of a reference.<p> 
+  </li> 
+  <li><a href="vtl-reference-guide.html#include">#include</a> &nbsp; - &nbsp; 
+   renders local file(s) that are not parsed by Velocity.<p>
+  </li>
+  <li><a href="vtl-reference-guide.html#parse">#parse</a> &nbsp; - &nbsp; 
+   renders a local template that is parsed by Velocity. <p>
+  </li>
+  <li><a href="vtl-reference-guide.html#stop">#stop</a> &nbsp; - &nbsp; 
+   stops the template engine. <p>
+  </li>
+</ul>
+
+</body>
+</html>
+
diff --git a/org.apache.click.eclipse/documentation/velocity/vtl-reference-guide.html b/org.apache.click.eclipse/documentation/velocity/vtl-reference-guide.html
new file mode 100644
index 0000000..d2eff16
--- /dev/null
+++ b/org.apache.click.eclipse/documentation/velocity/vtl-reference-guide.html
@@ -0,0 +1,644 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+
+<!-- Content Stylesheet for Site -->
+
+        
+<!-- start the processing -->
+    <!-- ====================================================================== -->
+    <!-- Main Page Section -->
+    <!-- ====================================================================== -->
+    <html>
+        <head>
+            <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"/>
+
+                                                    <meta name="author" value="Velocity Documentation Team">
+            <meta name="email" value="jvanzyl@zenplex.com">
+                                        <meta name="author" value="John Castura">
+            <meta name="email" value="jcastura@apache.org">
+            
+           
+                                    
+            <title>Velocity - VTL Reference Guide</title>
+            <style>
+              a:visited { color: blue; }
+              body	{ font-family: arial, helvetica, sans-serif; }
+            </style>
+        </head>
+
+        <body bgcolor="#ffffff" text="#000000" link="#525D76">        
+            <table border="0" width="100%" cellspacing="4">
+            
+      <tr><td bgcolor="#525D76">&nbsp;
+        <font size="+2" color="#ffffff" face="arial,helvetica,sanserif">
+          <strong>VTL Reference Guide</strong>
+        </font>
+      </td></tr>
+      
+                <tr><td colspan="2">
+                    <hr noshade="" size="1"/>
+                </td></tr>
+                
+
+      <tr><td>
+        <blockquote>
+                                    <p>
+    This guide is the reference for the Velocity Template Language
+    (VTL). For more information, please also refer to the <a href="user-guide.html">Velocity User Guide</a>.
+</p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="References"><strong>References</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                        <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Variables"><strong>Variables</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Notation:
+    </p>
+                                                <p>
+    <strong>$</strong> [ <strong>!</strong> ][ <strong>{</strong> ][
+    <strong>a..z</strong>, <strong>A..Z</strong> ][ <strong>a..z</strong>,
+    <strong>A..Z</strong>, <strong>0..9</strong>, <strong>-</strong>,
+    <strong>_</strong> ][ <strong>}</strong> ]
+    </p>
+                                                <p>
+    Examples:
+    </p>
+                                                <ul>
+        <li>Normal notation: <variable>$mud-Slinger_9</variable></li>
+        <li>Silent notation: <variable>$!mud-Slinger_9</variable></li>
+        <li>Formal notation: <variable>${mud-Slinger_9}</variable></li>
+    </ul>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                    <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Properties"><strong>Properties</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Notation:
+    </p>
+                                                <p>
+      <strong>$</strong> [ <strong>{</strong> ][ <strong>a..z</strong>,
+      <strong>A..Z</strong> ][ <strong>a..z</strong>, <strong>A..Z</strong>,
+      <strong>0..9</strong>, <strong>-</strong>, <strong>_</strong> ]*
+      <strong>.</strong>[<strong>a..z</strong>, <strong>A..Z</strong> ][
+      <strong>a..z</strong>, <strong>A-Z</strong>, <strong>0..9</strong>,
+      <strong>-</strong>, <strong>_</strong> ]* [ <strong>}</strong> ]
+    </p>
+                                                <p>
+    Examples:
+    </p>
+                                                <ul>
+        <li>Regular Notation: $customer.Address</li>
+        <li>Formal Notation: ${purchase.Total}</li>
+    </ul>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                    <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Methods"><strong>Methods</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Notation:
+    </p>
+                                                <p>
+      <strong>$</strong> [ <strong>{</strong> ][ <strong>a..z</strong>,
+      <strong>A..Z</strong> ][ <strong>a..z</strong>, <strong>A..Z</strong>,
+      <strong>0..9</strong>, <strong>-</strong>, <strong>_</strong> ]*
+      <strong>.</strong>[ <strong>a..z</strong>, <strong>A..Z</strong> ][
+      <strong>a..z</strong>, <strong>A..Z</strong>, <strong>0..9</strong>,
+      <strong>-</strong>, <strong>_</strong> ]*<strong>(</strong> [
+      <i>opional parameter list...</i> ] <strong>)</strong> [
+      <strong> } </strong>]
+    </p>
+                                                <p>
+    Examples:
+    </p>
+                                                <ul>
+      <li>Regular Notation: $customer.getAddress()</li>
+      <li>Formal Notation: ${purchase.getTotal()}</li>
+      <li>Regular Notation with Parameter List: $page.setTitle( "My Home
+      Page" )</li>
+    </ul>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <p>
+  VTL Properties can be used as a shorthand notation for VTL Methods
+  that take <em>get</em> and <em>set</em>. Either
+  <em>$object.getMethod()</em> or <em>$object.setMethod()</em> can be
+  abbreviated as <em>$object.Method</em>. It is generally preferable to
+  use a Property when available. The main difference between Properties
+  and Methods is that you can specify a parameter list to a Method.
+  </p>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Directives"><strong>Directives</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                        <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="set"><strong>#set - Establishes the value of a reference</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Format:
+    </p>
+                                                <p>
+    <strong>#set( $</strong>ref <strong>=</strong> [ <strong>"</strong>,
+    <strong>'</strong> ]arg[ <strong>"</strong>, <strong>'</strong> ] )
+    </p>
+                                                <p>
+    Usage:
+    </p>
+                                                <ul>
+    <li><em>$ref</em> - The LHS of the assignment must be a variable
+    reference or a property reference.</li>
+    <li><em>arg</em> - The RHS of the assignment, <em>arg</em> is parsed
+    if enclosed in double quotes, and not parsed if enclosed in single
+    quotes.  If the RHS evaluates to <em>null</em>, it is <b>not</b>
+    assigned to the LHS.</li>
+    </ul>
+                                                <p>
+    Examples:
+    </p>
+                                                <ul>
+      <li>Variable reference: #set( $monkey = "bill" )</li>
+      <li>String literal: #set( $monkey.Friend = "monica" )</li>
+      <li>Property reference: #set( $monkey.Blame = $whitehouse.Leak
+      )</li>
+      <li>Method reference: #set( $monkey.Plan = $spindoctor.weave($web)
+      )</li>
+      <li>Number literal: #set( $monkey.Number = 123 )</li>
+      <li>Range operator: #set( $monkey.Numbers = [1..3] )</li>
+      <li>Object array: #set( $monkey.Say = ["Not", $my, "fault"] )</li>
+    </ul>
+                                                <p>
+    The RHS can also be a simple arithmetic expression, such as:
+    </p>
+                                                <ul>
+      <li>Addition: #set( $value = $foo + 1 )</li>
+      <li>Subtraction: #set( $value = $bar - 1 )</li>
+      <li>Multiplication: #set( $value = $foo * $bar )</li>
+      <li>Division: #set( $value = $foo / $bar )</li>
+      <li>Remainder: #set( $value = $foo % $bar )</li>
+    </ul>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                    <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="if"><strong>#if / #elseif / #else - output conditional on truth   of statements</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Format:
+    </p>
+                                                <p>
+    <strong>#if(</strong> [condition] <strong>)</strong> [output] [
+    <strong>#elseif( </strong>[condition] <strong>)</strong> [output] ]* [
+    <strong>#else</strong> [output] ]
+    <strong>#end</strong>
+    </p>
+                                                <p>
+    Usage:
+    </p>
+                                                <ul>
+    <li><em>condition</em> - If a boolean, considered true if it has a
+    true false; if not a boolean, considered true if not null.</li>
+    <li><em>output</em> - May contain VTL.</li>
+    </ul>
+                                                <p>
+    Examples:
+    </p>
+                                                <ul>
+       <li>Equivalent Operator: #if( $foo == $bar )</li>
+       <li>Greater Than: #if( $foo &gt; 42 )</li>
+       <li>Less Than: #if( $foo &lt; 42 )</li>
+       <li>Greater Than or Equal To: #if( $foo &gt;= 42 )</li>
+       <li>Less Than or Equal To: #if( $foo &lt;= 42 )</li>
+       <li>Equals Number: #if( $foo == 42 )</li>
+       <li>Equals String: #if( $foo == "bar" )</li>
+       <li>Boolean NOT: #if( !$foo )</li>
+    </ul>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                    <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="foreach"><strong>#foreach - Loops through a list of objects</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Format:
+    </p>
+                                                <p>
+    <strong>#foreach(</strong> <em>$ref</em> <strong>in</strong> <em>arg</em>
+    <strong>)</strong> <em>statement</em> <strong>#end</strong>
+    </p>
+                                                <p>
+    Usage:
+    </p>
+                                                <ul>
+    <li><em>$ref</em> - The first variable reference is the item.</li>
+
+    <li><em>arg</em> - May be one of the following: a reference to a
+        list (i.e. object array, collection, or map), an array list, or
+        the range operator.</li>
+
+    <li>
+    <em>statement</em> - What is output each time Velocity finds a
+    valid item in the list denoted above as <i>arg</i>.  This output is
+    any valid VTL and is rendered each iteration of the loop.
+    </li>
+
+    </ul>
+                                                <p>
+    Examples of the #foreach(), omitting the statement block :
+    </p>
+                                                <ul>
+      <li>Reference: #foreach ( $item in $items )</li>
+      <li>Array list: #foreach ( $item in ["Not", $my, "fault"] )</li>
+      <li>Range operator: #foreach ( $item in [1..3] )</li>
+    </ul>
+                                                <p>
+    Velocity provides an easy way to get the loop counter so that you
+    can do something like the following:
+    </p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+&lt;table&gt;
+#foreach( $customer in $customerList )
+    &lt;tr&gt;&lt;td&gt;$velocityCount&lt;/td&gt;&lt;td&gt;$customer.Name&lt;/td&gt;&lt;/tr&gt;
+#end
+&lt;/table&gt;
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+    The default name for the loop counter variable reference, which is
+    specified in the velocity.properties file, is $velocityCount. By
+    default the counter starts at 1, but this can be set to either 0 or
+    1 in the <code>velocity.properties</code> file. Here's what the loop
+    counter properties section of the <code>velocity.properties</code>
+    file appears:
+    </p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+# Default name of the loop counter
+# variable refernce.
+counter.name = velocityCount
+
+# Default starting value of the loop
+# counter variable reference.
+counter.initial.value = 1
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                    <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="include"><strong>#include - Renders local file(s) that are not                     parsed by Velocity</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Format:
+    </p>
+                                                <p>
+    <strong>#include( </strong>arg[, arg2, ... argn]<strong> )</strong>
+    </p>
+                                                <ul>
+    <li><em>arg</em> - Refers to a valid file under TEMPLATE_ROOT.</li>
+    </ul>
+                                                <p>
+    Examples:
+    </p>
+                                                <ul>
+      <li>String: #include( "disclaimer.txt", "opinion.txt" )</li>
+      <li>Variable: #include( $foo, $bar )</li>
+    </ul>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                    <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="parse"><strong>#parse - Renders a local template that is parsed by                     Velocity</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Format:
+    </p>
+                                                <p>
+    <strong>#parse(</strong> arg <strong>)</strong>
+    </p>
+                                                <ul>
+    <li><em>arg</em> - Refers to a template under TEMPLATE_ROOT.</li>
+    </ul>
+                                                <p>
+    Examples:
+    </p>
+                                                <ul>
+      <li>String: #parse( "lecorbusier.vm" )</li>
+      <li>Variable: #parse( $foo )</li>
+    </ul>
+                                                <p>
+    Recursion permitted. See <em>parse_directive.maxdepth</em> in
+    <code>velocity.properties</code>
+    to change from parse depth. (The default parse depth is 10.)
+    </p>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                    <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="stop"><strong>#stop - Stops the template engine</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Format:
+    </p>
+                                                <p>
+    <strong>#stop</strong>
+    </p>
+                                                <p>
+    Usage:
+    </p>
+                                                <p>
+    This will stop execution of the current template. This is good for
+    debugging a template.
+    </p>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                    <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="macro"><strong>#macro - Allows users to define a Velocimacro (VM),         a repeated segment of a VTL template, as required</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Format:
+    </p>
+                                                <p>
+    <strong>#macro(</strong> vmname $arg1[, $arg2, $arg3, ... $argn ]
+    <strong>)</strong> [ VM VTL code... ] <strong>#end</strong>
+    </p>
+                                                <ul>
+    <li><em>vmname</em> - Name used to call the VM
+    (<em>#vmname</em>)</li>
+    <li><em>$arg1 $arg2 [ ... ]</em> - Arguments to the VM. There can be
+    any number of argumentss, but the number used at invocation must
+    match the number specified in the definition.</li>
+    <li><em>[ VM VTL code... ]</em> - Any valid VTL code, anything you
+    can put into a template, can be put into a VM.</li>
+    </ul>
+                                                <p>
+    Once defined, the VM is used like any other VTL directive in a
+    template.
+    </p>
+                                                    <div align="left">
+    <table cellspacing="4" cellpadding="0" border="0">
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#ffffff"><pre>
+#vmname( $arg1 $arg2 )
+</pre></td>
+      <td bgcolor="#023264" width="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    <tr>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+      <td bgcolor="#023264" width="1" height="1"><img src="/images/void.gif" width="1" height="1" vspace="0" hspace="0" border="0"/></td>
+    </tr>
+    </table>
+    </div>
+                                                <p>
+    VMs can be defined in one of two places:
+    </p>
+                                                <ol>
+    <li><i>Template library:</i> can be either VMs pre-packaged with
+    Velocity or custom-made, user-defined, site-specific VMs;
+     available from any template</li>
+    <li><i>Inline:</i> found in regular templates, only usable when
+    <em>velocimacro.permissions.allowInline=true</em> in
+    <code>velocity.properties</code>.</li>
+    </ol>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#525D76">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Comments"><strong>Comments</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Comments are not rendered at runtime.
+    </p>
+                                                    <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Single Line"><strong>Single Line</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Example:
+    </p>
+                                                <p>
+    <strong>## This is a comment.</strong>
+    </p>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                                    <table border="0" cellspacing="0" cellpadding="2" width="100%">
+      <tr><td bgcolor="#828DA6">
+        <font color="#ffffff" face="arial,helvetica,sanserif">
+          <a name="Multi Line"><strong>Multi Line</strong></a>
+        </font>
+      </td></tr>
+      <tr><td>
+        <blockquote>
+                                    <p>
+    Example:
+    </p>
+                                                <p>
+    <strong>
+    #*<br />
+    This is a multiline comment.<br />
+    This is the second line<br />
+    *#
+    </strong>
+    </p>
+                            </blockquote>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                            </blockquote>
+        </p>
+      </td></tr>
+      <tr><td><br/></td></tr>
+    </table>
+                                        </td>
+                </tr>
+
+                <!-- FOOTER -->
+                <tr><td colspan="2">
+                    <hr noshade="" size="1"/>
+                </td></tr>
+                <tr><td colspan="2">
+                    <div align="center"><font color="#525D76" size="-1"><em>
+                    Copyright &#169; 1999-2002, Apache Software Foundation
+                    </em></font></div>
+                </td></tr>
+            </table>
+        </body>
+    </html>
+<!-- end the processing -->
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/org.apache.click.eclipse/icons/class.gif b/org.apache.click.eclipse/icons/class.gif
new file mode 100644
index 0000000..e4c2a83
--- /dev/null
+++ b/org.apache.click.eclipse/icons/class.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/click-icon-16x16.png b/org.apache.click.eclipse/icons/click-icon-16x16.png
new file mode 100644
index 0000000..a453047
--- /dev/null
+++ b/org.apache.click.eclipse/icons/click-icon-16x16.png
Binary files differ
diff --git a/org.apache.click.eclipse/icons/click.gif b/org.apache.click.eclipse/icons/click.gif
new file mode 100644
index 0000000..8bd77dc
--- /dev/null
+++ b/org.apache.click.eclipse/icons/click.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/control.gif b/org.apache.click.eclipse/icons/control.gif
new file mode 100644
index 0000000..d143fcf
--- /dev/null
+++ b/org.apache.click.eclipse/icons/control.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/directive.gif b/org.apache.click.eclipse/icons/directive.gif
new file mode 100644
index 0000000..5d1f81b
--- /dev/null
+++ b/org.apache.click.eclipse/icons/directive.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/field.gif b/org.apache.click.eclipse/icons/field.gif
new file mode 100644
index 0000000..1fe064e
--- /dev/null
+++ b/org.apache.click.eclipse/icons/field.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/folder.gif b/org.apache.click.eclipse/icons/folder.gif
new file mode 100644
index 0000000..51e703b
--- /dev/null
+++ b/org.apache.click.eclipse/icons/folder.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/header.gif b/org.apache.click.eclipse/icons/header.gif
new file mode 100644
index 0000000..5c0a481
--- /dev/null
+++ b/org.apache.click.eclipse/icons/header.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/localvar.gif b/org.apache.click.eclipse/icons/localvar.gif
new file mode 100644
index 0000000..8adce95
--- /dev/null
+++ b/org.apache.click.eclipse/icons/localvar.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/method.gif b/org.apache.click.eclipse/icons/method.gif
new file mode 100644
index 0000000..7d24707
--- /dev/null
+++ b/org.apache.click.eclipse/icons/method.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/page.gif b/org.apache.click.eclipse/icons/page.gif
new file mode 100644
index 0000000..efa7a38
--- /dev/null
+++ b/org.apache.click.eclipse/icons/page.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/page_add.gif b/org.apache.click.eclipse/icons/page_add.gif
new file mode 100644
index 0000000..33a55fe
--- /dev/null
+++ b/org.apache.click.eclipse/icons/page_add.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/property.gif b/org.apache.click.eclipse/icons/property.gif
new file mode 100644
index 0000000..d4cb425
--- /dev/null
+++ b/org.apache.click.eclipse/icons/property.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/switch.gif b/org.apache.click.eclipse/icons/switch.gif
new file mode 100644
index 0000000..7b1efa5
--- /dev/null
+++ b/org.apache.click.eclipse/icons/switch.gif
Binary files differ
diff --git a/org.apache.click.eclipse/icons/velocity.gif b/org.apache.click.eclipse/icons/velocity.gif
new file mode 100644
index 0000000..aa9b947
--- /dev/null
+++ b/org.apache.click.eclipse/icons/velocity.gif
Binary files differ
diff --git a/org.apache.click.eclipse/lib/commons-collections-3.1.jar b/org.apache.click.eclipse/lib/commons-collections-3.1.jar
new file mode 100644
index 0000000..41e230f
--- /dev/null
+++ b/org.apache.click.eclipse/lib/commons-collections-3.1.jar
Binary files differ
diff --git a/org.apache.click.eclipse/lib/velocity-1.5-dev.jar b/org.apache.click.eclipse/lib/velocity-1.5-dev.jar
new file mode 100644
index 0000000..1d673cc
--- /dev/null
+++ b/org.apache.click.eclipse/lib/velocity-1.5-dev.jar
Binary files differ
diff --git a/org.apache.click.eclipse/memo.txt b/org.apache.click.eclipse/memo.txt
new file mode 100644
index 0000000..a7c049d
--- /dev/null
+++ b/org.apache.click.eclipse/memo.txt
@@ -0,0 +1,6 @@
+ClickIDE Development Memo
+--
+2.1.0.0
+
+ * Supports Apache Click 2.1.0 / Eclipse 3.5
+ * Toggle Comment action (CTRL + /) in the Template Editor.
\ No newline at end of file
diff --git a/org.apache.click.eclipse/plugin.properties b/org.apache.click.eclipse/plugin.properties
new file mode 100644
index 0000000..8e2fa37
--- /dev/null
+++ b/org.apache.click.eclipse/plugin.properties
@@ -0,0 +1,33 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+plugin.name=ClickIDE
+plugin.provider=Naoki Takezoe
+wizard.category=Click
+wizard.newPage=Click Page
+editor.clickXML=Click Configuration Editor
+editor.template=Click Template Editor
+contentType.clickXML=Click Configuration File
+contentType.template=Click Page Template
+validator.clickXML=Click Configuration Validator
+preference.wizardTemplate=Wizard Template
+preference.templateEditor=Template Editor
+action.newClickPage=New Click Page
+action.switchToHTML=Switch to HTML
+action.switchToClass=Switch to Class
+preset.name=Apache Click 2.1.0 Project
+preset.description=Configures a Dynamic Web application to use Apache Click 2.1.0
diff --git a/org.apache.click.eclipse/plugin.xml b/org.apache.click.eclipse/plugin.xml
new file mode 100644
index 0000000..492bafd
--- /dev/null
+++ b/org.apache.click.eclipse/plugin.xml
@@ -0,0 +1,367 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<plugin>
+   <extension-point id="configurationProvider" name="configurationProvider" schema="schema/configurationProvider.exsd"/>
+  <!--===============================================-->
+  <!-- Project Facet -->
+  <!--===============================================-->
+  <extension
+        id="org.apache.click.eclipse.core.facet"
+        name="Click"
+        point="org.eclipse.wst.common.project.facet.core.facets">
+
+    <project-facet id="click">
+      <label>Click</label>
+      <description>Click Description</description>
+    </project-facet>
+
+    <project-facet-version facet="click" version="2.1.0">
+       <constraint>
+        <and>
+          <requires facet="jst.web" version="[2.3"/>
+        </and>
+      </constraint>
+    </project-facet-version>
+
+    <action
+          facet="click"
+          id="click.install"
+          type="install"
+          version="2.1.0">
+      <delegate class="org.apache.click.eclipse.core.facet.ClickFacetInstallDelegate"/>
+      <config-factory class="org.apache.click.eclipse.core.facet.ClickFacetInstallDataModelProvider"/>
+      <!--
+      <config-factory class="net.sf.clickide.core.facet.ClickFacetInstallConfig$Factory"/>
+      -->
+    </action>
+
+	<action
+       facet="click"
+       id="click.uninstall"
+       type="uninstall"
+       version="2.1.0">
+      <delegate class="org.apache.click.eclipse.core.facet.ClickFacetUninstallDelegate"/>
+ 	</action>
+  </extension>
+
+  <extension point="org.eclipse.wst.common.project.facet.core.runtimes">
+    <supported>
+      <runtime-component any="true"/>
+      <facet id="click" version="2.1.0"/>
+    </supported>
+  </extension>
+
+  <extension
+        point="org.eclipse.wst.common.project.facet.ui.wizardPages">
+     <wizard-pages action="click.install">
+        <page class="org.apache.click.eclipse.ui.wizard.ClickFacetWizardPage"/>
+     </wizard-pages>
+  </extension>
+  
+  <extension
+        point="org.eclipse.wst.common.project.facet.core.presets">
+     <static-preset id="preset.click.2_1_0">
+	    <label>%preset.name</label>
+	    <facet id="jst.java" version="5.0" />
+	    <facet id="jst.web" version="2.4"/>
+	    <facet id="click" version="2.1.0" />
+     <description>%preset.description</description>
+     </static-preset>
+  </extension>
+  
+  <!--===============================================-->
+  <!-- Wizards -->
+  <!--===============================================-->
+  <extension point="org.eclipse.ui.newWizards">
+     <wizard
+           category="org.apache.click.eclipse.category"
+           class="org.apache.click.eclipse.ui.wizard.NewClickPageWizard"
+           icon="icons/click-icon-16x16.png"
+           id="org.apache.click.eclipse.ui.wizard.NewClickPageWizard"
+           name="%wizard.newPage"/>
+     <category
+           id="org.apache.click.eclipse.category"
+           name="%wizard.category"/>
+  </extension>
+
+  <!--===============================================-->
+  <!-- Editors -->
+  <!--===============================================-->
+  <extension point = "org.eclipse.ui.editors">
+    <editor
+          class="org.apache.click.eclipse.ui.editor.ClickEditor"
+          contributorClass="org.apache.click.eclipse.ui.editor.ClickActionBarContributor"
+          default="true"
+          filenames="click.xml"
+          icon="icons/click.gif"
+          id="org.apache.click.eclipse.ui.editor.ClickEditor"
+          name="%editor.clickXML">
+    </editor>
+    <editor
+          class="org.apache.click.eclipse.ui.editor.TemplateEditor"
+          contributorClass="org.apache.click.eclipse.ui.editor.TemplateEditorActionContributor"
+          default="true"
+          extensions="htm"
+          icon="icons/velocity.gif"
+          id="org.apache.click.eclipse.ui.editor.TemplateEditor"
+          name="%editor.template">
+    </editor>
+  </extension>
+
+  <extension point="org.eclipse.core.runtime.contentTypes">
+    <content-type
+      base-type="org.eclipse.core.runtime.xml"
+      default-charset="UTF-8"
+      file-names="click.xml"
+      id="click"
+      name="%contentType.clickXML"
+      priority="high">
+    </content-type>
+    <!--
+    <content-type
+          base-type="org.eclipse.wst.html.core.htmlsource"
+          default-charset="UTF-8"
+          file-extensions="htm"
+          id="template"
+          name="%contentType.template"
+          priority="high"/>
+    -->
+  </extension>
+
+  <extension point="org.eclipse.wst.sse.ui.editorConfiguration">
+    <sourceViewerConfiguration
+      class="org.apache.click.eclipse.ui.editor.ClickXMLTextViewerConfiguration"
+      target="org.apache.click.eclipse.click" />
+    <!--
+    <contentOutlineConfiguration
+      class="org.springframework.ide.eclipse.beans.ui.editor.outline.BeansContentOutlineConfiguration"
+      target="org.apache.click.eclipse.click"/>
+    -->
+    <!--
+    <sourceViewerConfiguration
+      class="org.apache.click.eclipse.ui.editor.TemplateEditorConfiguration"
+      target="org.apache.click.eclipse.template"/>
+    -->
+  </extension>
+  <extension
+      id="clickTemplateValidator"
+      name="Click Template Validator"
+      point="org.eclipse.wst.validation.validator">
+    <validator>
+      <projectNature id="org.eclipse.wst.common.modulecore.ModuleCoreNature"/>
+      <projectNature id="org.eclipse.jdt.core.javanature"/>
+      <filter
+            nameFilter="*.htm"
+            objectClass="org.eclipse.core.resources.IFile"/>
+      <helper
+            class="org.eclipse.wst.validation.internal.operations.WorkbenchContext">
+      </helper>
+      <run
+            enabled="true"
+            class="org.apache.click.eclipse.core.validator.TemplateValidator">
+      </run>
+    </validator>
+  </extension>
+  <extension
+        point="org.eclipse.help.toc">
+     <toc
+           file="toc.xml"
+           primary="true"/>
+  </extension>
+  <extension
+        point="org.eclipse.ui.actionSets">
+     <actionSet
+           id="org.apache.click.eclipse.ui.actionSet"
+           label="Click Action Set"
+           >
+        <menu
+              id="clickMenu"
+              label="Click">
+           <separator name="clickGroup"/>
+        </menu>
+        <action
+              class="org.apache.click.eclipse.ui.actions.NewClickPageAction"
+              icon="icons/click-icon-16x16.png"
+              id="org.apache.click.eclipse.ui.actions.NewClickPageAction"
+              label="%action.newClickPage"
+              toolbarPath="clickGroup"
+              tooltip="New Click page"
+              menubarPath="clickMenu/clickGroup"/>
+     </actionSet>
+  </extension>
+  <extension
+        point="org.eclipse.ui.preferencePages">
+     <page
+           class="org.apache.click.eclipse.preferences.ClickPreferencePage"
+           id="org.apache.click.eclipse.preferences.ClickPreferencePage"
+           name="Click"/>
+     <page
+           class="org.apache.click.eclipse.preferences.ClickTemplatePreferencePage"
+           id="org.apache.click.eclipse.preferences.ClickTemplatePreferencePage"
+           name="%preference.wizardTemplate"
+           category="org.apache.click.eclipse.preferences.ClickPreferencePage"/>
+     <page
+           category="org.apache.click.eclipse.preferences.ClickPreferencePage"
+           class="org.apache.click.eclipse.preferences.TemplateEditorPreferencePage"
+           id="org.apache.click.eclipse.preferences.TemplateEditorPreferencePage"
+           name="%preference.templateEditor"/>
+  </extension>
+  <extension
+        point="org.eclipse.core.runtime.preferences">
+     <initializer class="org.apache.click.eclipse.preferences.ClickPreferenceInitializer"/>
+  </extension>
+
+  <!--===============================================-->
+  <!-- Editor Actions -->
+  <!--===============================================-->
+  <extension
+        point="org.eclipse.ui.editorActions">
+     <editorContribution
+           id="org.apache.click.eclipse.editorContribution1"
+           targetID="org.eclipse.jdt.ui.CompilationUnitEditor">
+        <menu
+              id="clickMenu"
+              label="Click">
+           <separator name="clickGroup"/>
+        </menu>
+        <action
+              class="org.apache.click.eclipse.ui.actions.SwitchToHTMLAction"
+              definitionId="org.apache.click.eclipse.ui.actions.SwitchToHTMLAction"
+              icon="icons/switch.gif"
+              id="org.apache.click.eclipse.ui.actions.SwitchToHTMLAction"
+              label="%action.switchToHTML"
+              menubarPath="clickMenu/clickGroup"
+              style="push"/>
+     </editorContribution>
+     <editorContribution
+           id="org.apache.click.eclipse.editorContribution2"
+           targetID="org.eclipse.wst.html.core.htmlsource.source">
+        <menu
+              id="clickMenu"
+              label="Click">
+           <separator name="clickGroup"/>
+        </menu>
+        <action
+              class="org.apache.click.eclipse.ui.actions.SwitchToClassAction"
+              definitionId="org.apache.click.eclipse.ui.actions.SwitchToClassAction"
+              icon="icons/switch.gif"
+              id="org.apache.click.eclipse.ui.actions.SwitchToClassAction"
+              label="%action.switchToClass"
+              menubarPath="clickMenu/clickGroup"
+              style="push"/>
+     </editorContribution>
+     <editorContribution
+           id="org.apache.click.eclipse.editorContribution3"
+           targetID="org.apache.click.eclipse.ui.editor.TemplateEditor">
+        <menu
+              id="clickMenu"
+              label="Click">
+           <separator name="clickGroup"/>
+        </menu>
+        <action
+              class="org.apache.click.eclipse.ui.actions.SwitchToClassAction"
+              definitionId="org.apache.click.eclipse.ui.actions.SwitchToClassAction"
+              icon="icons/switch.gif"
+              id="org.apache.click.eclipse.ui.actions.SwitchToClassAction"
+              label="%action.switchToClass"
+              menubarPath="clickMenu/clickGroup"
+              style="push"/>
+     </editorContribution>
+  </extension>
+  <extension
+        point="org.eclipse.ui.commands">
+     <command
+           categoryId="org.apache.click.eclipse.category"
+           id="org.apache.click.eclipse.ui.actions.SwitchToHTMLAction"
+           name="%action.switchToHTML"/>
+     <command
+           categoryId="org.apache.click.eclipse.category"
+           id="org.apache.click.eclipse.ui.actions.SwitchToClassAction"
+           name="%action.switchToClass"/>
+     <category
+           id="net.sf.clickide.category"
+           name="Click"/>
+  </extension>
+  <extension
+        point="org.eclipse.ui.bindings">
+     <key
+           commandId="org.apache.click.eclipse.ui.actions.SwitchToHTMLAction"
+           contextId="org.eclipse.jdt.ui.javaEditorScope"
+           schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
+           sequence="Ctrl+Alt+S"/>
+     <key
+           commandId="org.apache.click.eclipse.ui.actions.SwitchToClassAction"
+           contextId="org.eclipse.wst.sse.ui.structuredTextEditorScope"
+           schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
+           sequence="Ctrl+Alt+S"/>
+  </extension>
+  <!--===============================================-->
+  <!-- Nature and Builders -->
+  <!--===============================================-->
+  <extension
+        id="ClickProjectNature"
+        name="ClickProjectNature"
+        point="org.eclipse.core.resources.natures">
+     <requires-nature id="org.eclipse.jdt.core.javanature"/>
+     <requires-nature id="org.eclipse.wst.common.project.facet.core.nature"/>
+     <requires-nature id="org.eclipse.wst.common.modulecore.ModuleCoreNature"/>
+     <requires-nature id="org.eclipse.jem.workbench.JavaEMFNature"/>
+     <runtime>
+        <run class="org.apache.click.eclipse.core.builder.ClickProjectNature"/>
+     </runtime>
+     <builder id="org.apache.click.eclipse.ClickProjectBuilder"/>
+  </extension>
+  <extension
+        id="ClickProjectBuilder"
+        name="%validator.clickXML"
+        point="org.eclipse.core.resources.builders">
+     <builder hasNature="true">
+        <run class="org.apache.click.eclipse.core.builder.ClickProjectBuilder"/>
+     </builder>
+  </extension>
+  <extension
+        point="org.eclipse.ui.perspectiveExtensions">
+     <perspectiveExtension targetID="org.eclipse.jst.j2ee.J2EEPerspective">
+        <actionSet id="org.apache.click.eclipse.ui.actionSet"/>
+     </perspectiveExtension>
+  </extension>
+  <!--===============================================-->
+  <!-- Property Pages -->
+  <!--===============================================-->
+  <extension
+        point="org.eclipse.ui.propertyPages">
+      <page
+            class="org.apache.click.eclipse.preferences.ClickProjectPropertyPage"
+            id="org.apache.click.eclipse.preferences.ClickProjectPropertyPage"
+            name="Click">
+         <enabledWhen>
+            <adapt
+                  type="org.eclipse.core.resources.IProject">
+            </adapt>
+         </enabledWhen>
+         <filter
+               name="nature"
+               value="org.apache.click.eclipse.ClickProjectNature">
+         </filter>
+      </page>
+  </extension>
+
+</plugin>
diff --git a/org.apache.click.eclipse/plugin_ja.properties b/org.apache.click.eclipse/plugin_ja.properties
new file mode 100644
index 0000000..98a3659
--- /dev/null
+++ b/org.apache.click.eclipse/plugin_ja.properties
@@ -0,0 +1,33 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+plugin.name=ClickIDE
+plugin.provider=Naoki Takezoe
+wizard.category=Click
+wizard.newPage=Click\u30da\u30fc\u30b8
+editor.clickXML=Click\u8a2d\u5b9a\u30a8\u30c7\u30a3\u30bf
+editor.template=Click\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8\u30a8\u30c7\u30a3\u30bf
+contentType.clickXML=Click\u8a2d\u5b9a\u30d5\u30a1\u30a4\u30eb
+contentType.template=Click\u30da\u30fc\u30b8\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8
+validator.clickXML=Click\u8a2d\u5b9a\u30d0\u30ea\u30c7\u30fc\u30bf
+preference.wizardTemplate=\u30a6\u30a3\u30b6\u30fc\u30c9\u30fb\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8
+preference.templateEditor=\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8\u30fb\u30a8\u30c7\u30a3\u30bf
+action.newClickPage=\u65b0\u898fClick\u30da\u30fc\u30b8\u306e\u4f5c\u6210
+action.switchToHTML=HTML\u30d5\u30a1\u30a4\u30eb\u306b\u5207\u308a\u66ff\u3048
+action.switchToClass=\u30da\u30fc\u30b8\u30af\u30e9\u30b9\u306b\u5207\u308a\u66ff\u3048
+preset.name=Apache Click 2.1.0\u30d7\u30ed\u30b8\u30a7\u30af\u30c8
+preset.description=Apache Click 2.1.0\u3092\u4f7f\u7528\u3059\u308b\u305f\u3081\u306b\u52d5\u7684Web\u30a2\u30d7\u30ea\u30b1\u30fc\u30b7\u30e7\u30f3\u3092\u69cb\u6210\u3057\u307e\u3059
diff --git a/org.apache.click.eclipse/schema/configurationProvider.exsd b/org.apache.click.eclipse/schema/configurationProvider.exsd
new file mode 100644
index 0000000..74402e3
--- /dev/null
+++ b/org.apache.click.eclipse/schema/configurationProvider.exsd
@@ -0,0 +1,128 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<!-- Schema file written by PDE -->
+<schema targetNamespace="net.sf.clickide">
+<annotation>
+      <appInfo>
+         <meta.schema plugin="net.sf.clickide" id="configurationProvider" name="configurationProvider"/>
+      </appInfo>
+      <documentation>
+         [Enter description of this extension point.]
+      </documentation>
+   </annotation>
+
+   <element name="extension">
+      <complexType>
+         <sequence minOccurs="1" maxOccurs="unbounded">
+            <element ref="configurationProvider"/>
+         </sequence>
+         <attribute name="point" type="string" use="required">
+            <annotation>
+               <documentation>
+
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="id" type="string">
+            <annotation>
+               <documentation>
+
+               </documentation>
+            </annotation>
+         </attribute>
+         <attribute name="name" type="string">
+            <annotation>
+               <documentation>
+
+               </documentation>
+               <appInfo>
+                  <meta.attribute translatable="true"/>
+               </appInfo>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <element name="configurationProvider">
+      <annotation>
+         <appInfo>
+            <meta.element labelAttribute="class"/>
+         </appInfo>
+      </annotation>
+      <complexType>
+         <attribute name="class" type="string">
+            <annotation>
+               <documentation>
+
+               </documentation>
+               <appInfo>
+                  <meta.attribute kind="java" basedOn=":net.sf.clickide.core.config.IClickConfigurationProvider"/>
+               </appInfo>
+            </annotation>
+         </attribute>
+      </complexType>
+   </element>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="since"/>
+      </appInfo>
+      <documentation>
+         [Enter the first release in which this extension point appears.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="examples"/>
+      </appInfo>
+      <documentation>
+         [Enter extension point usage example here.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="apiInfo"/>
+      </appInfo>
+      <documentation>
+         [Enter API information here.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="implementation"/>
+      </appInfo>
+      <documentation>
+         [Enter information about supplied implementation of this extension point.]
+      </documentation>
+   </annotation>
+
+   <annotation>
+      <appInfo>
+         <meta.section type="copyright"/>
+      </appInfo>
+      <documentation>
+
+      </documentation>
+   </annotation>
+
+</schema>
diff --git a/org.apache.click.eclipse/spring-2.5.6/lib/commons-logging-1.1.1.jar b/org.apache.click.eclipse/spring-2.5.6/lib/commons-logging-1.1.1.jar
new file mode 100644
index 0000000..1deef14
--- /dev/null
+++ b/org.apache.click.eclipse/spring-2.5.6/lib/commons-logging-1.1.1.jar
Binary files differ
diff --git a/org.apache.click.eclipse/spring-2.5.6/lib/spring-2.5.6.jar b/org.apache.click.eclipse/spring-2.5.6/lib/spring-2.5.6.jar
new file mode 100644
index 0000000..5273670
--- /dev/null
+++ b/org.apache.click.eclipse/spring-2.5.6/lib/spring-2.5.6.jar
Binary files differ
diff --git a/org.apache.click.eclipse/spring-2.5.6/spring-beans.xml b/org.apache.click.eclipse/spring-2.5.6/spring-beans.xml
new file mode 100644
index 0000000..3cc5723
--- /dev/null
+++ b/org.apache.click.eclipse/spring-2.5.6/spring-beans.xml
@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+   Licensed to the Apache Software Foundation (ASF) under one
+   or more contributor license agreements.  See the NOTICE file
+   distributed with this work for additional information
+   regarding copyright ownership.  The ASF licenses this file
+   to you under the Apache License, Version 2.0 (the
+   "License"); you may not use this file except in compliance
+   with the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing,
+   software distributed under the License is distributed on an
+   "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+   KIND, either express or implied.  See the License for the
+   specific language governing permissions and limitations
+   under the License.
+-->
+
+<beans:beans xmlns="http://www.springframework.org/schema/security"
+  xmlns:beans="http://www.springframework.org/schema/beans"
+  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+  xmlns:context="http://www.springframework.org/schema/context"
+  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
+     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
+     http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-2.0.4.xsd">
+
+    <context:component-scan base-package="${rootPackage}" scope-resolver="org.apache.click.extras.spring.PageScopeResolver"/>
+
+</beans:beans>
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickPlugin.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickPlugin.java
new file mode 100644
index 0000000..4b21da8
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickPlugin.java
@@ -0,0 +1,233 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse;
+
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.ResourceBundle;
+
+
+import org.apache.click.eclipse.core.config.DefaultClickConfigurationProvider;
+import org.apache.click.eclipse.core.config.IClickConfigurationProvider;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.resource.ImageDescriptor;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.osgi.framework.BundleContext;
+
+/**
+ * The main plugin class to be used in the desktop.
+ *
+ * @author Naoki Takezoe
+ */
+public class ClickPlugin extends AbstractUIPlugin {
+
+	public static final String PLUGIN_ID = "org.apache.click.eclipse";
+
+	//The shared instance.
+	private static ClickPlugin plugin;
+	private ResourceBundle resource;
+	private ColorManager colorManager;
+
+	private List<IClickConfigurationProvider> 
+		configProviders = new ArrayList<IClickConfigurationProvider>();
+
+	public static final String CLICK_PAGE_CLASS = "org.apache.click.Page";
+	public static final String CLICK_CONTROL_IF = "org.apache.click.Control";
+
+	public static final String TAG_CLICK_APP = "click-app";
+	public static final String TAG_HEADERS = "headers";
+	public static final String TAG_HEADER = "header";
+	public static final String TAG_PAGES = "pages";
+	public static final String TAG_PAGE = "page";
+	public static final String TAG_CONTROLS = "controls";
+	public static final String TAG_CONTROL = "control";
+	public static final String TAG_CONTROL_SET = "control-set";
+	public static final String TAG_FORMAT = "format";
+	public static final String TAG_MODE = "mode";
+	public static final String TAG_EXCLUDES = "excludes";
+	public static final String TAG_PROPERTY = "property";
+	public static final String TAG_FILE_UPLOAD_SERVICE = "file-upload-service";
+	public static final String TAG_LOG_SERVICE = "log-service";
+	public static final String TAG_TEMPLATE_SERVICE = "template-service";
+	public static final String TAG_RESOURCE_SERVICE = "resource-service";
+	public static final String ATTR_CHARSET = "charset";
+	public static final String ATTR_LOCALE = "locale";
+	public static final String ATTR_CLASSNAME = "classname";
+	public static final String ATTR_TYPE = "type";
+	public static final String ATTR_NAME = "name";
+	public static final String ATTR_VALUE = "value";
+	public static final String ATTR_PATH = "path";
+	public static final String ATTR_AUTO_MAPPING = "automapping";
+	public static final String ATTR_AUTO_BINDING = "autobinding";
+	public static final String ATTR_PACKAGE = "package";
+	public static final String ATTR_PATTERN = "pattern";
+
+	public static final String[] BOOLEAN_VALUES = {"true", "false"};
+	public static final String[] AUTO_BINDING_VALUES = {"annotation", "public", "none"};
+	public static final String[] LOGTO_VALUES = {"console", "servlet"};
+	public static final String[] MODE_VALUES = {"production", "profile", "development", "debug", "trace"};
+	public static final String[] HEADER_TYPE_VALUES = {"String", "Integer", "Date"};
+
+	public static final String PREF_TEMPLATES = "click.templates";
+	public static final String PREF_COLOR_VAR = "click.color.variable";
+	public static final String PREF_COLOR_DIR = "click.color.directive";
+	public static final String PREF_COLOR_CMT = "click.color.comment";
+	public static final String PREF_VELOCITY_VARS = "click.velocity.variables";
+
+	/**
+	 * The constructor.
+	 */
+	public ClickPlugin() {
+		plugin = this;
+		resource = ResourceBundle.getBundle("org.apache.click.eclipse.ClickPlugin");
+
+		configProviders.addAll(loadContributedClasses(
+				"configurationProvider", "configurationProvider"));
+		configProviders.add(new DefaultClickConfigurationProvider());
+	}
+
+	public ResourceBundle getResourceBundle(){
+		return this.resource;
+	}
+
+	private static List<IClickConfigurationProvider> loadContributedClasses(String extPointId, String elementName){
+		List<IClickConfigurationProvider> result = new ArrayList<IClickConfigurationProvider>();
+		try {
+			IExtensionRegistry registry = Platform.getExtensionRegistry();
+			IExtensionPoint point = registry.getExtensionPoint(PLUGIN_ID + "." + extPointId);
+			IExtension[] extensions = point.getExtensions();
+			for (int i = 0; i < extensions.length; i++) {
+				IConfigurationElement[] elements = extensions[i].getConfigurationElements();
+				for (int j = 0; j < elements.length; j++) {
+					if (elementName.equals(elements[j].getName())) {
+						result.add((IClickConfigurationProvider) elements[j].createExecutableExtension("class"));
+					}
+				}
+			}
+		} catch (Exception ex) {
+			log(ex);
+		}
+		return result;
+	}
+
+	public ColorManager getColorManager(){
+		if(this.colorManager==null){
+			this.colorManager = new ColorManager();
+		}
+		return this.colorManager;
+	}
+
+	/**
+	 * Returns the localized message from <tt>ClickPlugin.properties</tt>.
+	 *
+	 * @param key the message key
+	 * @return the localized message
+	 */
+	public static String getString(String key){
+		return getDefault().resource.getString(key);
+	}
+
+	/**
+	 * Returns the localized message from <tt>ClickPlugin.properties</tt>.
+	 * The message would be formatted with given substitutions.
+	 *
+	 * @param key the message key
+	 * @param substitutions the substitutions
+	 * @return the localized and formatted message
+	 */
+	public static String getString(String key, Object [] substitutions){
+		return MessageFormat.format(getString(key), substitutions);
+	}
+
+	/**
+	 * This method is called upon plug-in activation
+	 */
+	public void start(BundleContext context) throws Exception {
+		super.start(context);
+	}
+
+	/**
+	 * This method is called when the plug-in is stopped
+	 */
+	public void stop(BundleContext context) throws Exception {
+		super.stop(context);
+		colorManager.dispose();
+		plugin = null;
+	}
+
+	/**
+	 * Returns the shared instance.
+	 */
+	public static ClickPlugin getDefault() {
+		return plugin;
+	}
+
+	/**
+	 * Returns an image descriptor for the image file at the given
+	 * plug-in relative path.
+	 *
+	 * @param path the path
+	 * @return the image descriptor
+	 */
+	public static ImageDescriptor getImageDescriptor(String path) {
+		return AbstractUIPlugin.imageDescriptorFromPlugin(PLUGIN_ID, path);
+	}
+
+	/**
+	 * Logs the given <code>Throwable</code>.
+	 *
+	 * @param t the <code>Throwable</code> instance which would be logged
+	 */
+	public static void log(Throwable t){
+		IStatus status = new Status(
+				IStatus.ERROR, getDefault().getBundle().getSymbolicName(),
+				IStatus.ERROR, t.toString(), t);
+
+		getDefault().getLog().log(status);
+
+		try {
+			IWorkbenchPage page = ClickUtils.getActivePage();
+			MessageDialog.openError(page.getWorkbenchWindow().getShell(),
+					ClickPlugin.getString("message.error"), t.toString());
+		} catch(Exception ex){
+			// ignore
+		}
+	}
+
+	public IClickConfigurationProvider getConfigurationProvider(IProject project){
+		for(int i=0;i<configProviders.size();i++){
+			IClickConfigurationProvider configProvider
+				= (IClickConfigurationProvider) configProviders.get(i);
+			if(configProvider.isSupportedProject(project)){
+				return configProvider;
+			}
+		}
+		throw new RuntimeException("Can not find the configuration provider!");
+	}
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickPlugin.properties b/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickPlugin.properties
new file mode 100644
index 0000000..d14a22f
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickPlugin.properties
@@ -0,0 +1,120 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# commons
+message.error=Error
+
+# for editors
+editor.clickXML.general=General
+editor.clickXML.headers=Headers
+editor.clickXML.pages=Pages
+editor.clickXML.controls=Controls
+editor.clickXML.service=Service
+editor.clickXML.source=Source
+editor.clickXML.title=Click Configuration
+editor.clickXML.outline=Outline
+editor.clickXML.details=Details
+editor.clickXML.general.charset=Charset:
+editor.clickXML.general.locale=Locale:
+editor.clickXML.general.format=Format Class:
+editor.clickXML.general.mode=Mode:
+#editor.clickXML.general.logTo=Log To:
+editor.clickXML.controls.class=Class(*):
+editor.clickXML.controls.name=Name(*):
+editor.clickXML.headers.name=Name(*):
+editor.clickXML.headers.value=Value(*):
+editor.clickXML.headers.type=Type:
+editor.clickXML.pages.autoMapping=Auto Mapping:
+editor.clickXML.pages.autoBinding=Auto Binding:
+editor.clickXML.pages.package=Package:
+editor.clickXML.pages.path=Path:
+editor.clickXML.pages.class=Class:
+editor.clickXML.pages.excludePattern=Exclude Pattern:
+editor.clickXML.property.name=Name(*):
+editor.clickXML.property.value=Value(*):
+
+# for messages
+message.error.noPage=Unable to find the page class.
+message.error.noHtml=Unable to find the page HTML.
+
+# for actions
+action.delete=Delete
+action.browse=Browse...
+action.new=New
+action.add=&Add
+action.edit=&Edit
+action.remove=&Remove
+action.toggleComment=Toggle Comment
+
+# for wizards
+wizard.newPage.title=New Click Page
+wizard.newPage.description=Creates new Click page.
+wizard.newPage.progress=Creating the new Click page...
+wizard.newPage.project=Project:
+wizard.newPage.templateGroup=HTML template
+wizard.newPage.templateGroup.checkbox=Create HTML template file
+wizard.newPage.templateGroup.parentFolder=Parent folder:
+wizard.newPage.templateGroup.filename=Filename:
+wizard.newPage.pageClassGroup=Page class
+wizard.newPage.pageClassGroup.checkbox=Create page class
+wizard.newPage.pageClassGroup.sourceFolder=Source folder:
+wizard.newPage.pageClassGroup.package=Package:
+wizard.newPage.pageClassGroup.classname=Name:
+wizard.newPage.pageClassGroup.superclass=Superclass:
+wizard.newPage.addMapping=Add mapping to click.xml
+wizard.newPage.error.selectProject=Select project.
+wizard.newPage.error.notClickProject=''{0}'' isn't Click Project.
+wizard.newPage.error.folderDoesNotExist=Folder ''{0}'' does not exist.
+wizard.newPage.error.pageIsEmpty=Template filename is empty.
+wizard.newPage.error.fileAlreadyExists=File already exists.
+wizard.newPage.error.packageIsInvalid1=Package name is not valid. ''{0}'' is not a valid Java identifier
+wizard.newPage.error.packageIsInvalid2=Package name is not valid. A package name cannot start or end with a dot
+wizard.newPage.error.typeIsEmpty=Type name is empty.
+wizard.newPage.error.typeIsInvalid=Type name is not valid. The type name ''{0}'' is not a valid identifier
+wizard.newPage.error.typeAlreadyExists=Type already exists.
+wizard.newPage.error.defaultPackage=The use of the default package is discouraged.
+wizard.newPage.error.noTemplate=Template is not selected.
+wizard.newPage.dialog.selectProject=Select Project
+wizard.newPage.dialog.selectFolder=Select Folder
+wizard.newPage.dialog.selectSourceFolder=Select Source Folder
+wizard.facet.title=Options
+wizard.facet.description=Select additinal features for the Click project.
+wizard.facet.useSpring=Use Spring Framework
+wizard.facet.useCayenne=Use Apache Cayenne
+wizard.facet.usePerformanceFilter=Use PerformanceFilter
+wizard.facet.rootPackage=Root Package\uff1a
+wizard.facet.error.rootPackage.empty=Root Package is empty.
+
+# for preference pages
+preferences.template=Wizard Template
+preferences.template.name=Name
+preferences.template.pageClass=Page Class
+preferences.template.htmlTemplate=HTML Template
+preferences.template.dialog.variables=following valiables are available:
+preferences.templateEditor=Template Editor
+preferences.templateEditor.colorVariable=&Variable:
+preferences.templateEditor.colorDirective=&Directive:
+preferences.templateEditor.colorComment=&Comment:
+
+# for property pages
+propertyPage.variables.title=Click
+propertyPage.variables.description=Define Velocity Variables.
+propertyPage.variables.column.name=Name
+propertyPage.variables.column.type=Type
+propertyPage.variables.dialog.title=Velocity Variable
+propertyPage.variables.dialog.name=Name:
+propertyPage.variables.dialog.type=Type:
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickPlugin_ja.properties b/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickPlugin_ja.properties
new file mode 100644
index 0000000..c9fc305
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickPlugin_ja.properties
@@ -0,0 +1,120 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# commons
+message.error=\u30a8\u30e9\u30fc
+
+# for editors
+editor.clickXML.general=\u5168\u4f53
+editor.clickXML.headers=\u30d8\u30c3\u30c0
+editor.clickXML.pages=\u30da\u30fc\u30b8
+editor.clickXML.controls=\u30b3\u30f3\u30c8\u30ed\u30fc\u30eb
+editor.clickXML.service=\u30b5\u30fc\u30d3\u30b9
+editor.clickXML.source=\u30bd\u30fc\u30b9
+editor.clickXML.title=Click\u30a2\u30d7\u30ea\u30b1\u30fc\u30b7\u30e7\u30f3\u306e\u8a2d\u5b9a
+editor.clickXML.outline=\u30a2\u30a6\u30c8\u30e9\u30a4\u30f3
+editor.clickXML.details=\u8a73\u7d30
+editor.clickXML.general.charset=\u6587\u5b57\u30b3\u30fc\u30c9:
+editor.clickXML.general.locale=\u30ed\u30b1\u30fc\u30eb:
+editor.clickXML.general.format=\u30d5\u30a9\u30fc\u30de\u30c3\u30c8\u30af\u30e9\u30b9:
+editor.clickXML.general.mode=\u52d5\u4f5c\u30e2\u30fc\u30c9:
+#editor.clickXML.general.logTo=\u30ed\u30b0\u306e\u51fa\u529b\u5148:
+editor.clickXML.controls.class=\u30af\u30e9\u30b9(*):
+editor.clickXML.controls.name=\u540d\u524d(*)\uff1a
+editor.clickXML.headers.name=\u540d\u524d(*):
+editor.clickXML.headers.value=\u5024(*):
+editor.clickXML.headers.type=\u30bf\u30a4\u30d7:
+editor.clickXML.pages.autoMapping=\u81ea\u52d5\u30de\u30c3\u30d4\u30f3\u30b0:
+editor.clickXML.pages.autoBinding=\u81ea\u52d5\u30d0\u30a4\u30f3\u30c7\u30a3\u30f3\u30b0:
+editor.clickXML.pages.package=\u30d1\u30c3\u30b1\u30fc\u30b8:
+editor.clickXML.pages.path=\u30d1\u30b9:
+editor.clickXML.pages.class=\u30af\u30e9\u30b9:
+editor.clickXML.pages.excludePattern=\u9664\u5916\u3059\u308b\u30d1\u30bf\u30fc\u30f3:
+editor.clickXML.property.name=\u540d\u524d(*):
+editor.clickXML.property.value=\u5024(*):
+
+# for messages
+message.error.noPage=\u5bfe\u5fdc\u3059\u308b\u30da\u30fc\u30b8\u30af\u30e9\u30b9\u304c\u898b\u3064\u304b\u308a\u307e\u305b\u3093\u3002
+message.error.noHtml=\u5bfe\u5fdc\u3059\u308bHTML\u30d5\u30a1\u30a4\u30eb\u304c\u898b\u3064\u304b\u308a\u307e\u305b\u3093\u3002
+
+# for actions
+action.delete=\u524a\u9664
+action.browse=\u53c2\u7167...
+action.new=\u8ffd\u52a0
+action.add=\u8ffd\u52a0(&A)
+action.edit=\u7de8\u96c6(&E)
+action.remove=\u524a\u9664(&R)
+action.toggleComment=\u30b3\u30e1\u30f3\u30c8\u306e\u5207\u308a\u66ff\u3048
+
+# for wizards
+wizard.newPage.title=\u65b0\u898fClick\u30da\u30fc\u30b8
+wizard.newPage.description=\u65b0\u898fClick\u30da\u30fc\u30b8\u3092\u4f5c\u6210\u3057\u307e\u3059\u3002
+wizard.newPage.progress=\u65b0\u898fClick\u30da\u30fc\u30b8\u306e\u4f5c\u6210\u4e2d...
+wizard.newPage.project=\u30d7\u30ed\u30b8\u30a7\u30af\u30c8:
+wizard.newPage.templateGroup=HTML\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8
+wizard.newPage.templateGroup.checkbox=HTML\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8\u30fb\u30d5\u30a1\u30a4\u30eb\u3092\u4f5c\u6210\u3059\u308b
+wizard.newPage.templateGroup.parentFolder=\u89aa\u30d5\u30a9\u30eb\u30c0\u30fc:
+wizard.newPage.templateGroup.filename=\u30d5\u30a1\u30a4\u30eb\u540d:
+wizard.newPage.pageClassGroup=\u30da\u30fc\u30b8\u30af\u30e9\u30b9
+wizard.newPage.pageClassGroup.checkbox=\u30da\u30fc\u30b8\u30af\u30e9\u30b9\u3092\u4f5c\u6210\u3059\u308b
+wizard.newPage.pageClassGroup.sourceFolder=\u30bd\u30fc\u30b9\u30d5\u30a9\u30eb\u30c0:
+wizard.newPage.pageClassGroup.package=\u30d1\u30c3\u30b1\u30fc\u30b8:
+wizard.newPage.pageClassGroup.classname=\u540d\u524d:
+wizard.newPage.pageClassGroup.superclass=\u30b9\u30fc\u30d1\u30fc\u30af\u30e9\u30b9:
+wizard.newPage.addMapping=click.xml\u306b\u30de\u30c3\u30d4\u30f3\u30b0\u3092\u8ffd\u52a0\u3059\u308b
+wizard.newPage.error.selectProject=\u30d7\u30ed\u30b8\u30a7\u30af\u30c8\u3092\u9078\u629e\u3057\u3066\u304f\u3060\u3055\u3044\u3002
+wizard.newPage.error.notClickProject=''{0}''\u306fClick\u30d7\u30ed\u30b8\u30a7\u30af\u30c8\u3067\u306f\u3042\u308a\u307e\u305b\u3093\u3002
+wizard.newPage.error.folderDoesNotExist=\u30d5\u30a9\u30eb\u30c0\u30fc ''{0}'' \u304c\u5b58\u5728\u3057\u307e\u305b\u3093\u3002
+wizard.newPage.error.pageIsEmpty=\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8\u306e\u30d5\u30a1\u30a4\u30eb\u540d\u304c\u7a7a\u3067\u3059\u3002
+wizard.newPage.error.fileAlreadyExists=\u30d5\u30a1\u30a4\u30eb\u306f\u3059\u3067\u306b\u5b58\u5728\u3057\u307e\u3059\u3002
+wizard.newPage.error.packageIsInvalid1=\u30d1\u30c3\u30b1\u30fc\u30b8\u540d\u304c\u6b63\u3057\u304f\u3042\u308a\u307e\u305b\u3093\u3002 ''{0}'' \u306f\u6709\u52b9\u306a Java \u8b58\u5225\u5b50\u3067\u306f\u3042\u308a\u307e\u305b\u3093
+wizard.newPage.error.packageIsInvalid2=\u30d1\u30c3\u30b1\u30fc\u30b8\u540d\u304c\u6b63\u3057\u304f\u3042\u308a\u307e\u305b\u3093\u3002 \u30d1\u30c3\u30b1\u30fc\u30b8\u540d\u3092\u30c9\u30c3\u30c8\u3067\u958b\u59cb\u307e\u305f\u306f\u7d42\u4e86\u3059\u308b\u3053\u3068\u306f\u3067\u304d\u307e\u305b\u3093
+wizard.newPage.error.typeIsEmpty=\u578b\u540d\u304c\u7a7a\u3067\u3059\u3002
+wizard.newPage.error.typeIsInvalid=\u578b\u540d\u306f\u7121\u52b9\u3067\u3059\u3002 \u578b\u540d ''{0}'' \u306f\u6709\u52b9\u306a\u8b58\u5225\u5b50\u3067\u306f\u3042\u308a\u307e\u305b\u3093
+wizard.newPage.error.typeAlreadyExists=\u578b\u306f\u3059\u3067\u306b\u5b58\u5728\u3057\u307e\u3059\u3002
+wizard.newPage.error.defaultPackage=\u30c7\u30d5\u30a9\u30eb\u30c8\u30fb\u30d1\u30c3\u30b1\u30fc\u30b8\u306e\u4f7f\u7528\u306f\u63a8\u5968\u3055\u308c\u307e\u305b\u3093\u3002
+wizard.newPage.error.noTemplate=\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8\u304c\u9078\u629e\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002
+wizard.newPage.dialog.selectProject=\u30d7\u30ed\u30b8\u30a7\u30af\u30c8\u306e\u9078\u629e
+wizard.newPage.dialog.selectFolder=\u30d5\u30a9\u30eb\u30c0\u306e\u9078\u629e
+wizard.newPage.dialog.selectSourceFolder=\u30bd\u30fc\u30b9\u30d5\u30a9\u30eb\u30c0\u306e\u9078\u629e
+wizard.facet.title=\u30aa\u30d7\u30b7\u30e7\u30f3
+wizard.facet.description=Click\u30d7\u30ed\u30b8\u30a7\u30af\u30c8\u306b\u8ffd\u52a0\u3059\u308b\u30d5\u30ec\u30fc\u30e0\u30ef\u30fc\u30af\u3092\u9078\u629e\u3057\u3066\u304f\u3060\u3055\u3044\u3002
+wizard.facet.useSpring=Spring Framework\u3092\u4f7f\u7528\u3059\u308b
+wizard.facet.useCayenne=Apache Cayenne\u3092\u4f7f\u7528\u3059\u308b
+wizard.facet.usePerformanceFilter=PerformanceFilter\u3092\u4f7f\u7528\u3059\u308b
+wizard.facet.rootPackage=\u30eb\u30fc\u30c8\u30d1\u30c3\u30b1\u30fc\u30b8\uff1a
+wizard.facet.error.rootPackage.empty=\u30eb\u30fc\u30c8\u30d1\u30c3\u30b1\u30fc\u30b8\u304c\u5165\u529b\u3055\u308c\u3066\u3044\u307e\u305b\u3093\u3002
+
+# for preference pages
+preferences.template=\u30a6\u30a3\u30b6\u30fc\u30c9\u30fb\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8
+preferences.template.name=\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8\u540d
+preferences.template.pageClass=\u30da\u30fc\u30b8\u30af\u30e9\u30b9
+preferences.template.htmlTemplate=HTML\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8
+preferences.template.dialog.variables=\u4ee5\u4e0b\u306e\u5909\u6570\u304c\u5229\u7528\u53ef\u80fd\u3067\u3059:
+preferences.templateEditor=\u30c6\u30f3\u30d7\u30ec\u30fc\u30c8\u30fb\u30a8\u30c7\u30a3\u30bf
+preferences.templateEditor.colorVariable=\u5909\u6570(&V):
+preferences.templateEditor.colorDirective=\u30c7\u30a3\u30ec\u30af\u30c6\u30a3\u30d6(&D):
+preferences.templateEditor.colorComment=\u30b3\u30e1\u30f3\u30c8(&C):
+
+# for property pages
+propertyPage.variables.title=Click
+propertyPage.variables.description=Velocity\u5909\u6570\u3092\u5b9a\u7fa9\u3057\u307e\u3059\u3002
+propertyPage.variables.column.name=\u5909\u6570\u540d
+propertyPage.variables.column.type=\u578b
+propertyPage.variables.dialog.title=Velocity\u5909\u6570
+propertyPage.variables.dialog.name=\u5909\u6570\u540d:
+propertyPage.variables.dialog.type=\u578b:
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickUtils.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickUtils.java
new file mode 100644
index 0000000..b9e16bb
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ClickUtils.java
@@ -0,0 +1,790 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse;
+
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.eclipse.core.resources.IContainer;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jdt.core.IImportDeclaration;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jst.j2ee.internal.deployables.J2EEFlexProjDeployable;
+import org.eclipse.jst.j2ee.web.componentcore.util.WebArtifactEdit;
+import org.eclipse.jst.j2ee.webapplication.JSPType;
+import org.eclipse.jst.j2ee.webapplication.Servlet;
+import org.eclipse.jst.j2ee.webapplication.ServletMapping;
+import org.eclipse.jst.j2ee.webapplication.ServletType;
+import org.eclipse.jst.j2ee.webapplication.WebApp;
+import org.eclipse.jst.j2ee.webapplication.WebapplicationFactory;
+import org.eclipse.jst.j2ee.webapplication.WelcomeFileList;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.wst.common.componentcore.ComponentCore;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.project.facet.core.IFacetedProject;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
+import org.eclipse.wst.sse.core.StructuredModelManager;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+import org.w3c.dom.NodeList;
+
+
+/**
+ * Provides utility methods for ClickIDE.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickUtils {
+	
+	public static final String CLICK_SERVLET_NAME = "ClickServlet";
+	public static final String CLICK_SERVLET_CLASS = "org.apache.click.ClickServlet";
+	public static final String CLICK_SPRING_SERVLET_CLASS = "org.apache.click.extras.spring.SpringClickServlet";
+	public static final String CAYENNE_FILTER_CLASS = "org.apache.click.extras.cayenne.DataContextFilter";
+	public static final String DEFAULT_FORMAT_CLASS = "org.apache.click.util.Format";
+	
+	/**
+	 * Creates <code>GridData</code>.
+	 * 
+	 * @param colspan the horizontal span
+	 * @param style the style constants
+	 * @return the created <code>GridData</code>
+	 */
+	public static GridData createGridData(int colspan, int style){
+		GridData gd = new GridData(style);
+		gd.horizontalSpan = colspan;
+		return gd;
+	}
+	
+	/**
+	 * Creates <code>GridLayout</code> that has no margins.
+	 * 
+	 * @param columns 
+	 * @return the created <code>GridLayout</code>
+	 */
+	public static GridLayout createGridLayout(int columns){
+		GridLayout layout = new GridLayout(columns, false);
+		layout.marginBottom = 0;
+		layout.marginTop = 0;
+		layout.marginLeft = 0;
+		layout.marginRight = 0;
+		layout.marginHeight = 0;
+		layout.marginWidth = 0;
+		return layout;
+	}
+	
+	/**
+	 * Creates <code>Label</code>.
+	 * 
+	 * @param parent the parent composite
+	 * @param text the text which will be displayed on the Label
+	 * @return created Label
+	 */
+	public static Label createLabel(Composite parent, String text){
+		Label label = new Label(parent, SWT.NULL);
+		label.setText(text);
+		return label;
+	}
+	
+	/**
+	 * Escape XML special charactors.
+	 * 
+	 * @param value the string
+	 * @return the escaped string
+	 */
+	public static String escapeXML(String value){
+		value = value.replaceAll("&", "&amp;");
+		value = value.replaceAll("<", "&lt;");
+		value = value.replaceAll(">", "&gt;");
+		value = value.replaceAll("\"", "&quot;");
+		return value;
+	}
+	
+	public static boolean isClickProject(IProject project){
+		IVirtualComponent component = ComponentCore.createComponent(project);
+		try {
+			if(WebArtifactEdit.isValidWebModule(component)){
+				IFacetedProject facetedProject = ProjectFacetsManager.create(project);
+				Object facets[] = facetedProject.getProjectFacets().toArray();
+				for(int i=0;i<facets.length;i++){
+					IProjectFacetVersion facet = (IProjectFacetVersion)facets[i];
+					if(facet.getProjectFacet().getId().equals("click")){
+						return true;
+					}
+				}
+			}
+		} catch(Exception ex){
+			ex.printStackTrace();
+		}
+		return false;
+	}
+	
+	/**
+	 * Returns IFile that was related with IDocument.
+	 * 
+	 * @param document the document object
+	 * @return the file that was related with the specified document
+	 */
+	public static IFile getResource(IDocument document) {
+		IFile resource = null;
+		String baselocation = null;
+
+		if (document != null) {
+			IStructuredModel model = null;
+			try {
+				model = StructuredModelManager.getModelManager().getExistingModelForRead(document);
+				if (model != null) {
+					baselocation = model.getBaseLocation();
+				}
+			} finally {
+				if (model != null){
+					model.releaseFromRead();
+				}
+			}
+		}
+
+		if (baselocation != null) {
+			IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
+			IPath filePath = new Path(baselocation);
+			if (filePath.segmentCount() > 0) {
+				resource = root.getFile(filePath);
+			}
+		}
+		return resource;
+	}
+	
+	/**
+	 * Returns <code>IJavaProject</code> from <code>Object</code>.
+	 * <p>
+	 * This method allows following types as input
+	 * <ul>
+	 *   <li><code>IJavaProject</code></li>
+	 *   <li><code>IJavaElement</code></li>
+	 *   <li><code>IResource</code></li>
+	 * </ul>
+	 * 
+	 * @param obj the input object
+	 * @return <code>IJavaProject</code> or <code>null</code>
+	 */
+	public static IJavaProject getJavaProject(Object obj){
+		if(obj instanceof IJavaProject){
+			return (IJavaProject)obj;
+		}
+		if(obj instanceof IJavaElement){
+			return ((IJavaElement)obj).getJavaProject();
+		}
+		if(obj instanceof IResource){
+			return JavaCore.create(((IResource)obj).getProject());
+		}
+		if(obj instanceof IAdaptable){
+			Object result = ((IAdaptable) obj).getAdapter(IJavaProject.class);
+			if(result instanceof IJavaProject){
+				return (IJavaProject) result;
+			} else if(result instanceof IProject){
+				return JavaCore.create((IProject) result);
+			}
+		}
+		try {
+			Method method = obj.getClass().getMethod("getProject", new Class[0]);
+			IJavaProject project = (IJavaProject)method.invoke(obj, new Object[0]);
+			return project;
+		} catch(Exception ex){
+		}
+		
+		return null;
+	}
+	
+	public static IPackageFragmentRoot getSourceFolder(Object obj){
+		if(obj instanceof IPackageFragmentRoot){
+			return (IPackageFragmentRoot)obj;
+		} else if(obj instanceof IJavaElement){
+			IJavaElement parent = ((IJavaElement)obj).getParent();
+			if(parent!=null){
+				return getSourceFolder(parent);
+			}
+		}
+		return null;
+	}
+	
+	/**
+	 * Returns the <code>WebArtifactEdit</code> from the project for write.
+	 * 
+	 * @param project the project
+	 * @return the <code>WebArtifactEdit</code> for write
+	 */
+	public static WebArtifactEdit getWebArtifactEditForWrite(IProject project) {
+		return WebArtifactEdit.getWebArtifactEditForWrite(project);
+	}
+	
+	/**
+	 * Returns the <code>WebArtifactEdit</code> from the project for read.
+	 * 
+	 * @param project the project
+	 * @return the <code>WebArtifactEdit</code> for read
+	 */
+	public static WebArtifactEdit getWebArtifactEditForRead(IProject project) {
+		return WebArtifactEdit.getWebArtifactEditForRead(project);
+	}
+	
+	/**
+	 * Finds the ClickServlet from the given <code>WebApp</code>.
+	 * Returns <code>null</code> if this nethod couldn't find ClickServlet.
+	 * 
+	 * @param webApp the <code>WebApp</code> object
+	 * @param useSpring If <code>true</code> then use Spring Framework with Click
+	 * @return the <code>Servlet</code> object of the ClickServlet or <code>null</code>
+	 */
+	public static Servlet findClickServlet(WebApp webApp, boolean useSpring) {
+		String servletClassName = useSpring ? CLICK_SPRING_SERVLET_CLASS : CLICK_SERVLET_CLASS;
+		
+		Servlet servlet = null;
+		@SuppressWarnings("unchecked")
+		Iterator it = webApp.getServlets().iterator();
+		
+		while (it.hasNext()) {
+			servlet = (Servlet) it.next();
+			if (servlet.getWebType().isServletType()) {
+				if (((ServletType) servlet.getWebType()).getClassName().equals(servletClassName)) {
+					break;
+				}
+			} else if (servlet.getWebType().isJspType()) {
+				if (((JSPType) servlet.getWebType()).getJspFile().equals(servletClassName)) {
+					break;
+				}
+			}
+		}
+		return servlet;
+	}
+	
+	/**
+	 * Removes the URL mapping from the given <code>WebApp</code>s.
+	 * 
+	 * @param webApp the <code>WebApp</code> object
+	 * @param servlet the <code>Servlet</code> object of the ClickServlet
+	 */
+	public static void removeURLMappings(WebApp webApp, Servlet servlet) {
+		String servletName = servlet.getServletName();
+		if (servletName != null) {
+			@SuppressWarnings("unchecked")
+			Iterator oldMappings = webApp.getServletMappings().iterator();
+			
+			while (oldMappings.hasNext()) {
+				ServletMapping mapping = (ServletMapping) oldMappings.next();
+				if (mapping.getServlet().getServletName().equals(servletName)) {
+					webApp.getServletMappings().remove(mapping);
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Creates the <code>welcome-file-list</code> which contains the <code>index.htm</code>.
+	 * 
+	 * @param webApp the <code>WebApp</code> object
+	 */
+	@SuppressWarnings("unchecked")
+	public static void createOrUpdateFilelist(WebApp webApp) {
+		WelcomeFileList filelist = webApp.getFileList();
+		
+		if(filelist==null){
+			filelist = WebapplicationFactory.eINSTANCE.createWelcomeFileList();
+			filelist.addFileNamed("index.htm");
+			filelist.setWebApp(webApp);
+		} else {
+			filelist.getFile().removeAll(filelist.getFile());
+			filelist.addFileNamed("index.htm");
+		}
+	}
+	
+	/**
+	 * Adds or updates the servlet information in the web.xml.
+	 * 
+	 * @param webApp  the <code>WebApp</code> object
+	 * @param config the facet installation configuration
+	 * @param servlet the <code>Servlet</code> object of the ClickServlet
+	 * @param useSpring If <code>true</code> then use Spring Framework with Click
+	 * @return the <code>Servlet</code> object of the ClickServlet
+	 */
+	@SuppressWarnings("unchecked")
+	public static Servlet createOrUpdateServletRef(WebApp webApp, IDataModel config, 
+			Servlet servlet, boolean useSpring) {
+		//String displayName = config.getStringProperty(CLICK_SERVLET_NAME);
+		
+		if (servlet == null) {
+			// Create the servlet instance and set up the parameters from data
+			// model
+			servlet = WebapplicationFactory.eINSTANCE.createServlet();
+			servlet.setServletName(CLICK_SERVLET_NAME);
+
+			ServletType servletType = WebapplicationFactory.eINSTANCE.createServletType();
+			if(useSpring){
+				servletType.setClassName(CLICK_SPRING_SERVLET_CLASS);
+//				if (webApp.getJ2EEVersionID() >= J2EEVersionConstants.J2EE_1_4_ID) {
+//					// J2EE 1.4
+//					ParamValue initParam = CommonFactory.eINSTANCE.createParamValue();
+//					initParam.setName("spring-path");
+//					initParam.setValue("/applicationContext.xml");
+//					servlet.getInitParams().add(initParam);
+//				} else {
+//					// J2EE 1.2 or 1.3
+//					InitParam initParam = WebapplicationFactory.eINSTANCE.createInitParam();
+//					initParam.setParamName("spring-path");
+//					initParam.setParamValue("/applicationContext.xml");
+//					servlet.getParams().add(initParam);
+//				}
+			} else {
+				servletType.setClassName(CLICK_SERVLET_CLASS);
+			}
+			servlet.setWebType(servletType);
+			servlet.setLoadOnStartup(new Integer(1));
+			
+			// Add the servlet to the web application model
+			webApp.getServlets().add(servlet);
+		} else {
+			// update
+			servlet.setServletName(CLICK_SERVLET_NAME);
+			servlet.setLoadOnStartup(new Integer(1));
+		}
+		return servlet;
+	}
+	
+	@SuppressWarnings("unchecked")
+	public static void setUpURLMappings(WebApp webApp, String[] urlMappingList, Servlet servlet) {
+		// Add mappings
+		for (int i=0;i<urlMappingList.length;i++) {
+			String pattern = urlMappingList[i];
+			ServletMapping mapping = WebapplicationFactory.eINSTANCE.createServletMapping();
+			mapping.setServlet(servlet);
+			mapping.setName(servlet.getServletName());
+			mapping.setUrlPattern(pattern);
+			webApp.getServletMappings().add(mapping);
+		}
+	}
+	
+	public static IDOMElement getElement(IDOMElement base, String tagName){
+		NodeList list = base.getElementsByTagName(tagName);
+		if(list.getLength()==0){
+			return null;
+		} else {
+			return (IDOMElement)list.item(0);
+		}
+	}
+	
+	public static String[] createComboValues(String[] values){
+		String[] result = new String[values.length + 1];
+		result[0] = "";
+		for(int i=0;i<values.length;i++){
+			result[i+1] = values[i];
+		}
+		return result;
+	}
+	
+	/**
+	 * Returns the path string of the web application root folder.
+	 * 
+	 * @param project the project
+	 * @return the path string of the web application root folder.
+	 *    If any errors occurs, returns blank string.
+	 */
+	public static String getWebAppRootFolder(IProject project){
+		try {
+			J2EEFlexProjDeployable deployable = new J2EEFlexProjDeployable(project);
+			IContainer[] containers = deployable.getResourceFolders();
+			if(containers.length > 0){
+				return containers[0].getProjectRelativePath().toString();
+			}
+		} catch(Exception ex){
+		}
+		return "";
+	}
+	
+	/**
+	 * Returns the active <code>IWorkbenchPage</code>.
+	 * 
+	 * @return the active workbench page
+	 */
+	public static IWorkbenchPage getActivePage(){
+		return PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
+	}
+	
+	/**
+	 * Returns the <code>IFile</code> of <tt>click.xml</tt> in the specified project.
+	 * 
+	 * @param project the project
+	 * @return <code>IFile</code> of <tt>click.xml</tt>
+	 */
+	public static IFile getClickConfigFile(IProject project){
+		String webAppRoot = getWebAppRootFolder(project);
+		IFile file = project.getFile(new Path(webAppRoot).append("WEB-INF/click.xml"));
+		if(file.exists()){
+			return file;
+		}
+		return null;
+	}
+	
+	/**
+	 * Returns the <code>IStructuredModel</code> of <tt>click.xml</tt> in the specified project.
+	 * 
+	 * @param project the project
+	 * @return <code>IStructuredModel</code> for <tt>click.xml</tt>
+	 */
+	public static IStructuredModel getClickXMLModel(IProject project){
+		IStructuredModel model = null;
+		try {
+			IFile file = ClickUtils.getClickConfigFile(project);
+			if(file==null){
+				return null;
+			}
+			model = StructuredModelManager.getModelManager().getModelForRead(file);
+		} catch(Exception ex){
+			ClickPlugin.log(ex);
+		}
+		return model;
+	}
+	
+	/**
+	 * Returns the charset.
+	 * If the charset is not specified, returns <code>null</code>.
+	 * 
+	 * @param project the project
+	 * @return the charset
+	 */
+	public static String getCharset(IProject project){
+		return ClickPlugin.getDefault().getConfigurationProvider(project).getCharset(project);
+	}
+	
+	/**
+	 * Returns <code>IType</code> of the format object.
+	 * If format element is not defined, this method returns <code>net.sf.click.util.Format</code>.
+	 * 
+	 * @param project the project
+	 * @return IType of the format object
+	 */
+	public static IType getFormat(IProject project){
+		return ClickPlugin.getDefault().getConfigurationProvider(project).getFormat(project);
+	}
+	
+	/**
+	 * Returns the status of the auto mapping in the specified project.
+	 * <p>
+	 * <strong>Note:</strong> The auto-mapping mode has been available 
+	 * in default since Click 1.1.
+	 * 
+	 * @param project the project
+	 * @return true if the auto mapping is enable; false otherwise
+	 */
+	public static boolean getAutoMapping(IProject project){
+		return ClickPlugin.getDefault().getConfigurationProvider(project).getAutoMapping(project);
+	}
+	
+	/**
+	 * Returns the package name of page classes.
+	 * If the package name is not specified, thie method returns <code>null</code>.
+	 * 
+	 * @param project the project
+	 * @return the package name of page classes or <code>null</code>
+	 */
+	public static String getPagePackageName(IProject project){
+		return ClickPlugin.getDefault().getConfigurationProvider(project).getPagePackageName(project);
+	}
+	
+	/**
+	 * Returns the the HTML file path which paired to the specified class.
+	 *  
+	 * @param project the project
+	 * @param className the classname
+	 * @return the HTML file path.
+	 *     If unable to find the paired HTML, returns <code>null</code>.
+	 */
+	public static String getHTMLfromClass(IProject project, String className){
+		return ClickPlugin.getDefault().getConfigurationProvider(project).getHTMLfromClass(project, className);
+	}
+	
+	/**
+	 * Returns proposals of template filenames.
+	 * <p>
+	 * If &quot;UseInfo&quot; is given, this method would return:
+	 * <ul>
+	 *   <li>user-info.htm</li>
+	 *   <li>user-info-page.htm</li>
+	 *   <li>user_info.htm</li>
+	 *   <li>user_info_page.htm</li>
+	 *   <li>UserInfo.htm</li>
+	 *   <li>userInfo.htm</li>
+	 *   <li>userInfoPage.htm</li>
+	 * </ul>
+	 * 
+	 * @param path the page classname which shouldn't contain package name. 
+	 *   Also, &quot;Page&quot; postfix should be removed.
+	 * @return proposals of template filenames.
+	 */
+	public static String[] getTempleteProposals(String path){
+		String lower = path.substring(0, 1).toLowerCase() + path.substring(1);
+		String hifun = path.replaceAll("([a-z])([A-Z])", "$1-$2").toLowerCase();
+		String under = path.replaceAll("([a-z])([A-Z])", "$1_$2").toLowerCase();
+		
+		List<String> list = new ArrayList<String>();
+		
+		list.add(path + ".htm");
+		list.add(path + "Page.htm");
+		list.add(lower + ".htm");
+		list.add(lower + "Page.htm");
+		list.add(hifun + ".htm");
+		list.add(hifun + "-page.htm");
+		list.add(under + ".htm");
+		list.add(under + "_page.htm");
+		
+		return list.toArray(new String[list.size()]);
+	}
+	
+	/**
+	 * Returns the full qualified classname of the page class
+	 * which paired to the specified HTML file.
+	 * 
+	 * @param project the project
+	 * @param htmlName the HTML file path which registered to the click.xml 
+	 * @return the full qulified classname.
+	 *   If unable to find the paired class, returns <code>null</code>.
+	 */
+	public static String getClassfromHTML(IProject project, String htmlName){
+		return ClickPlugin.getDefault().getConfigurationProvider(project).getClassfromHTML(project, htmlName);
+	}
+	
+	/**
+	 * Opens the message dialog which shows the given message.
+	 * 
+	 * @param message the display message
+	 * @see MessageDialog
+	 */
+	public static void openErrorDialog(String message){
+		IWorkbenchPage page = ClickUtils.getActivePage();
+		MessageDialog.openError(page.getWorkbenchWindow().getShell(),
+				ClickPlugin.getString("message.error"), message);
+	}
+	
+	/**
+	 * Returns the <code>IType</code> object of the page class 
+	 * which corresponded to the specified HTML template.
+	 * If it can't find the page class, this method returns <code>null</code>.
+	 * 
+	 * @param file the <code>IFile</code> object of the HTML template
+	 * @return the <code>IType</code> object of the page class
+	 * @see ClickUtils#getTemplateFromPageClass(IType)
+	 */
+	public static IType getPageClassFromTemplate(IFile file){
+		String fullpath = file.getProjectRelativePath().toString();
+		String root = ClickUtils.getWebAppRootFolder(file.getProject());
+		if(fullpath.startsWith(root)){
+			String path = fullpath.substring(root.length());
+			if(path.startsWith("/")){
+				path = path.substring(1);
+			}
+			String className = ClickUtils.getClassfromHTML(file.getProject(), path);
+			if(className!=null){
+				IJavaProject project = JavaCore.create(file.getProject());
+				try {
+					IType type = project.findType(className);
+					if(type!=null){
+						return type;
+					}
+				} catch(Exception ex){
+					ClickPlugin.log(ex);
+				}
+				try {
+					IType type = project.findType(className + "Page");
+					if(type!=null){
+						return type;
+					}
+				} catch(Exception ex){
+					ClickPlugin.log(ex);
+				}
+			}
+		}
+		return null;
+	}
+	
+	/**
+	 * Returns the <code>IFile</code> object of the HTML template which
+	 * correnponded to the specified page class.
+	 * If it can't find the HTML template, this method returns <code>null</code>.
+	 * 
+	 * @param type the <code>IType</code> object of the page class
+	 * @return the <code>IFile</code> object of the HTML template
+	 * @see ClickUtils#getPageClassFromTemplate(IFile)
+	 */
+	public static IFile getTemplateFromPageClass(IType type){
+		IProject project = type.getResource().getProject();
+		String html = ClickUtils.getHTMLfromClass(project, type.getFullyQualifiedName());
+		if(html!=null){
+			String root = ClickUtils.getWebAppRootFolder(project);
+			IFolder folder = project.getFolder(root);
+			IResource resource = folder.findMember(html);
+			if(resource!=null && resource instanceof IFile && resource.exists()){
+				return (IFile)resource;
+			}
+		}
+		return null;
+	}
+	
+	/**
+	 * Creates a qualified class name from a class name which doesn't contain package name.
+	 * 
+	 * @param parent a full qualified class name of the class which uses this variable
+	 * @param type a class name which doesn't contain package name
+	 * @return full a created qualified class name
+	 */
+	public static String resolveClassName(IType parent,String type){
+		if(type.indexOf('.') >= 0){
+			return type;
+		}
+		if(isPrimitive(type)){
+			return type;
+		}
+		IJavaProject project = parent.getJavaProject();
+		try {
+			IType javaType = project.findType("java.lang." + type);
+			if(javaType!=null && javaType.exists()){
+				return javaType.getFullyQualifiedName();
+			}
+		} catch(Exception ex){
+			ex.printStackTrace();
+		}
+		try {
+			IType javaType = project.findType(parent.getPackageFragment().getElementName() + "." + type);
+			if(javaType!=null && javaType.exists()){
+				return javaType.getFullyQualifiedName();
+			}
+		} catch(Exception ex){
+			ex.printStackTrace();
+		}
+		try {
+			IImportDeclaration[] imports = parent.getCompilationUnit().getImports();
+			for(int i=0;i<imports.length;i++){
+				String importName = imports[i].getElementName();
+				if(importName.endsWith("." + type)){
+					return importName;
+				}
+				if(importName.endsWith(".*")){
+					try {
+						IType javaType = project.findType(importName.replaceFirst("\\*$",type));
+						if(javaType!=null && javaType.exists()){
+							return javaType.getFullyQualifiedName();
+						}
+					} catch(Exception ex){
+					}
+				}
+			}
+		} catch(Exception ex){
+			ex.printStackTrace();
+		}
+		return type;
+	}
+	
+	/**
+	 * This method judges whether the type is a primitive type. 
+	 * 
+	 * @param type type (classname or primitive type)
+	 * @return 
+	 * <ul>
+	 *   <li>true - primitive type</li>
+	 *   <li>false - not primitive type</li>
+	 * </ul>
+	 */
+	public static boolean isPrimitive(String type){
+		if(type.equals("int") || type.equals("long") || type.equals("double") || type.equals("float") || 
+				type.equals("char") || type.equals("boolean") || type.equals("byte")){
+			return true;
+		}
+		return false;
+	}
+	
+	public static String removeTypeParameter(String name){
+		String simpleName = name;
+		if(simpleName.indexOf('<')>=0){
+			simpleName = simpleName.substring(0, simpleName.lastIndexOf('<'));
+		}
+		return simpleName;
+	}
+	
+	public static void copyStream(InputStream in, OutputStream out){
+		try {
+			byte[] buf = new byte[1024 * 8];
+			int length = 0;
+			while((length = in.read(buf))!=-1){
+				out.write(buf, 0, length);
+			}
+		} catch(IOException ex){
+			ClickPlugin.log(ex);
+		} finally {
+			closeQuietly(in);
+			closeQuietly(out);
+		}
+	}
+	
+	public static String readStream(InputStream in){
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		copyStream(in, out);
+		try {
+			return new String(out.toByteArray(), "UTF-8");
+		} catch(UnsupportedEncodingException ex){
+			throw new RuntimeException(ex);
+		}
+	}
+	
+	public static void closeQuietly(Closeable closeable){
+		if(closeable != null){
+			try {
+				closeable.close();
+			} catch(Exception ex){
+				;
+			}
+		}
+	}
+	
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ColorManager.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ColorManager.java
new file mode 100644
index 0000000..d0d50f8
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ColorManager.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jface.resource.StringConverter;
+import org.eclipse.jface.util.IPropertyChangeListener;
+import org.eclipse.jface.util.PropertyChangeEvent;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.widgets.Display;
+
+/**
+ * Manages SWT's <code>Color</code> objects which are configued by the preference page.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ColorManager {
+	
+	private IPreferenceStore store;
+	private Map<String, Color> colors = new HashMap<String, Color>();
+	
+	private IPropertyChangeListener listener = new IPropertyChangeListener(){
+		public void propertyChange(PropertyChangeEvent event) {
+			updateColors();
+		}
+	};
+	
+	public ColorManager(){
+		store = ClickPlugin.getDefault().getPreferenceStore();
+		store.addPropertyChangeListener(listener);
+		updateColors();
+	}
+	
+	/**
+	 * Returns the cached <code>Color<code> object.
+	 * 
+	 * @param key the preference key defined as the static variable in <code>ClickPlugin</code>
+	 * @return the <code>Color</code> object
+	 */
+	public Color get(String key){
+		return (Color)colors.get(key);
+	}
+	
+	private void updateColors(){
+		colors.put(ClickPlugin.PREF_COLOR_VAR, new Color(Display.getDefault(), 
+				StringConverter.asRGB(store.getString(ClickPlugin.PREF_COLOR_VAR))));
+		colors.put(ClickPlugin.PREF_COLOR_DIR, new Color(Display.getDefault(), 
+				StringConverter.asRGB(store.getString(ClickPlugin.PREF_COLOR_DIR))));
+		colors.put(ClickPlugin.PREF_COLOR_CMT, new Color(Display.getDefault(), 
+				StringConverter.asRGB(store.getString(ClickPlugin.PREF_COLOR_CMT))));
+	}
+	
+	private void disposeColors(){
+		for(Iterator<Color> i = colors.values().iterator(); i.hasNext();){
+			Color color = i.next();
+			color.dispose();
+		}
+		colors.clear();
+	}
+	
+	/**
+	 * Disposes all <code>Color</code> objects.
+	 */
+	public void dispose(){
+		disposeColors();
+		store.removePropertyChangeListener(listener);
+	}
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/builder/ClickProjectBuilder.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/builder/ClickProjectBuilder.java
new file mode 100644
index 0000000..14e449f
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/builder/ClickProjectBuilder.java
@@ -0,0 +1,111 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.builder;
+
+import java.util.Map;
+
+
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceDelta;
+import org.eclipse.core.resources.IResourceDeltaVisitor;
+import org.eclipse.core.resources.IncrementalProjectBuilder;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+
+/**
+ * The incremental builder for the Click project.
+ * 
+ * @author Naoki Takezoe
+ * @see ClickProjectNature
+ */
+public class ClickProjectBuilder extends IncrementalProjectBuilder {
+
+	/** The id of this builder. */
+	public static final String BUILDER_ID = "org.apache.click.eclipse.ClickProjectBuilder";
+	
+	private ClickXMLValidator validator = new ClickXMLValidator();
+
+	@SuppressWarnings("unchecked")
+	protected IProject[] build(int kind, Map args, IProgressMonitor monitor) throws CoreException {
+		if (kind == FULL_BUILD) {
+			fullBuild(monitor);
+		} else {
+			IResourceDelta delta = getDelta(getProject());
+			if (delta == null) {
+				fullBuild(monitor);
+			} else {
+				incrementalBuild(delta, monitor);
+			}
+		}
+		return null;
+	}
+	
+	protected void fullBuild(final IProgressMonitor monitor) throws CoreException {
+		IFile file = ClickUtils.getClickConfigFile(getProject());
+		if(file != null){
+			validator.validate(file, monitor);
+		}
+	}
+
+	protected void incrementalBuild(IResourceDelta delta, 
+			IProgressMonitor monitor) throws CoreException {
+		delta.accept(new ClickDeltaVisitor(monitor));
+	}
+	
+	private class ClickDeltaVisitor implements IResourceDeltaVisitor {
+		
+		private IProgressMonitor monitor;
+		
+		public ClickDeltaVisitor(IProgressMonitor monitor){
+			this.monitor = monitor;
+		}
+		
+		public boolean visit(IResourceDelta delta) throws CoreException {
+			IResource resource = delta.getResource();
+			if(resource instanceof IFile){
+				if(resource.getName().endsWith(".htm")){
+					fullBuild(monitor);
+					return false;
+				}
+				if(resource.getName().endsWith(".java")){
+					fullBuild(monitor);
+					return false;
+				}
+				if(resource.getName().endsWith(".class")){
+					fullBuild(monitor);
+					return false;
+				}
+				if(resource.getName().endsWith(".jar")){
+					fullBuild(monitor);
+					return false;
+				}
+				if(resource.getName().equals("click.xml")){
+					fullBuild(monitor);
+					return false;
+				}
+			}
+			return true;
+		}
+	}
+
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/builder/ClickProjectNature.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/builder/ClickProjectNature.java
new file mode 100644
index 0000000..ff0fc5c
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/builder/ClickProjectNature.java
@@ -0,0 +1,140 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.builder;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.eclipse.core.resources.ICommand;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.resources.IProjectNature;
+import org.eclipse.core.runtime.CoreException;
+
+/**
+ * The project nature for the Click project.
+ * <p>
+ * This nature enables <code>ClickProjectBuilder</code> for the project.
+ * 
+ * @author Naoki Takezoe
+ * @see ClickProjectBuilder
+ */
+public class ClickProjectNature implements IProjectNature {
+	
+	public static final String NATURE_ID = "org.apache.click.eclipse.ClickProjectNature";
+	
+	private IProject project;
+	
+	/**
+	 * Adds the <code>ClickProjectBuilder</code> to the project.
+	 */
+	public void configure() throws CoreException {
+		IProjectDescription desc = project.getDescription();
+		ICommand[] commands = desc.getBuildSpec();
+
+		for (int i = 0; i < commands.length; ++i) {
+			if (commands[i].getBuilderName().equals(ClickProjectBuilder.BUILDER_ID)) {
+				return;
+			}
+		}
+
+		ICommand[] newCommands = new ICommand[commands.length + 1];
+		System.arraycopy(commands, 0, newCommands, 0, commands.length);
+		ICommand command = desc.newCommand();
+		command.setBuilderName(ClickProjectBuilder.BUILDER_ID);
+		newCommands[newCommands.length - 1] = command;
+		desc.setBuildSpec(newCommands);
+		project.setDescription(desc, null);
+	}
+
+	/**
+	 * Removes the <code>ClickProjectBuilder</code> from the project.
+	 */
+	public void deconfigure() throws CoreException {
+		IProjectDescription description = getProject().getDescription();
+		ICommand[] commands = description.getBuildSpec();
+		for (int i = 0; i < commands.length; ++i) {
+			if (commands[i].getBuilderName().equals(ClickProjectBuilder.BUILDER_ID)) {
+				ICommand[] newCommands = new ICommand[commands.length - 1];
+				System.arraycopy(commands, 0, newCommands, 0, i);
+				System.arraycopy(commands, i + 1, newCommands, i,
+						commands.length - i - 1);
+				description.setBuildSpec(newCommands);
+				return;
+			}
+		}
+	}
+
+	public IProject getProject() {
+		return project;
+	}
+
+	public void setProject(IProject project) {
+		this.project = project;
+	}
+	
+	/**
+	 * Adds the <code>ClickProjectNature</code> to the given project.
+	 * 
+	 * @param project the project
+	 */
+	public static void addNatute(IProject project) {
+		try {
+			IProjectDescription description = project.getDescription();
+			String[] natures = description.getNatureIds();
+			
+			// Add the nature
+			String[] newNatures = new String[natures.length + 1];
+			System.arraycopy(natures, 0, newNatures, 0, natures.length);
+			newNatures[natures.length] = ClickProjectNature.NATURE_ID;
+			description.setNatureIds(newNatures);
+			project.setDescription(description, null);
+			
+		} catch(CoreException e){
+			ClickPlugin.log(e);
+		}
+	}
+	
+	/**
+	 * Removes the <code>ClickProjectNature</code> from the given project.
+	 * 
+	 * @param project the project
+	 */
+	public static void removeNature(IProject project){
+		try {
+			IProjectDescription description = project.getDescription();
+			String[] natures = description.getNatureIds();
+
+			for (int i = 0; i < natures.length; ++i) {
+				if (ClickProjectNature.NATURE_ID.equals(natures[i])) {
+					// Remove the nature
+					String[] newNatures = new String[natures.length - 1];
+					System.arraycopy(natures, 0, newNatures, 0, i);
+					System.arraycopy(natures, i + 1, newNatures, i,
+							natures.length - i - 1);
+					description.setNatureIds(newNatures);
+					project.setDescription(description, null);
+					return;
+				}
+			}
+		} catch (CoreException e) {
+			ClickPlugin.log(e);
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/builder/ClickXMLValidator.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/builder/ClickXMLValidator.java
new file mode 100644
index 0000000..4c98480
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/builder/ClickXMLValidator.java
@@ -0,0 +1,253 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.builder;
+
+import java.io.UnsupportedEncodingException;
+import java.text.MessageFormat;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.ResourceBundle;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IMarker;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.wst.sse.core.StructuredModelManager;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
+import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
+import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
+import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegionList;
+import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
+
+/**
+ * The validator for the click.xml.
+ * <p>
+ * This validator validates:
+ * </p>
+ * <ul>
+ *   <li>charset of &lt;click-app&gt;.</li>
+ *   <li>package of &lt;pages&gt;.</li>
+ *   <li>automapping of &lt;pages&gt;.</li>
+ *   <li>type of &lt;header&gt;.</li>
+ *   <li>classname of &lt;page&gt;, &lt;control&gt; and &lt;format&gt;.</li>
+ *   <li>value and logto of &lt;mode&gt;.</li>
+ * </ul>
+ * <p>
+ * All detected errors are marked as WARNING.
+ * </p>
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickXMLValidator {
+	
+	private static ResourceBundle resource 
+		= ResourceBundle.getBundle("org.apache.click.eclipse.core.validator.validation");
+	
+	private String packageName = null;
+	
+	/**
+	 * Validates click.xml.
+	 * 
+	 * @param file the <code>IFile</code> of click.xml.
+	 */
+	public void validate(IFile file, IProgressMonitor monitor){
+		
+		packageName = null;
+		
+		try {
+			file.deleteMarkers(IMarker.PROBLEM, false, 0);
+		} catch(Exception ex){
+			ClickPlugin.log(ex);
+		}
+		
+		IStructuredModel model = null;
+		
+		try {
+			model = StructuredModelManager.getModelManager().getModelForRead(file);
+			IStructuredDocument doc = model.getStructuredDocument();
+			IStructuredDocumentRegion curNode = doc.getFirstStructuredDocumentRegion();
+			while (null != (curNode = curNode.getNext()) && !monitor.isCanceled()) {
+				if (curNode.getType() == DOMRegionContext.XML_TAG_NAME) {
+					ITextRegionList list = curNode.getRegions();
+					String text = curNode.getText();
+					String tagName  = null;
+					String attrName = null;
+					for(int j=0;j<list.size();j++){
+						ITextRegion region = list.get(j);
+						if(region.getType()==DOMRegionContext.XML_TAG_NAME){
+							tagName = text.substring(region.getStart(), region.getEnd()).trim();
+							
+						} else if(region.getType()==DOMRegionContext.XML_TAG_ATTRIBUTE_NAME){
+							attrName = text.substring(region.getStart(), region.getEnd()).trim();
+							
+						} else if(region.getType()==DOMRegionContext.XML_TAG_ATTRIBUTE_VALUE){
+							String attrValue = text.substring(region.getStart(), region.getEnd()).trim();
+							int length = attrValue.length();
+							attrValue = attrValue.replaceAll("^\"|\"$","");
+							if(tagName!=null && attrName!=null){
+								validateAttributeValue(file, tagName, attrName, attrValue, 
+										curNode.getStart() + region.getStart(), length);
+							}
+							attrName = null;
+						}
+					}
+				}
+			}
+		} catch (Exception e) {
+			ClickPlugin.log(e);
+		} finally {
+			if (null != model){
+				model.releaseFromRead();
+			}
+		}
+	}
+	
+	/**
+	 * Validates the attribute value.
+	 */
+	private void validateAttributeValue(IFile file, 
+			String tagName, String attrName, String attrValue, int start, int length){
+		
+		// package of <pages>
+		if(tagName.equals(ClickPlugin.TAG_PAGES) && attrName.equals(ClickPlugin.ATTR_PACKAGE)){
+			packageName = attrValue;
+			return;
+		}
+		
+		// classname of <control>, <page>, <format> and <xxx-service>
+		if(tagName.equals(ClickPlugin.TAG_CONTROL) || tagName.equals(ClickPlugin.TAG_PAGE) || tagName.equals(ClickPlugin.TAG_FORMAT) ||
+				tagName.equals(ClickPlugin.TAG_LOG_SERVICE) || tagName.equals(ClickPlugin.TAG_TEMPLATE_SERVICE) || 
+				tagName.equals(ClickPlugin.TAG_FILE_UPLOAD_SERVICE) || tagName.equals(ClickPlugin.TAG_RESOURCE_SERVICE)){
+			
+			if(tagName.equals(ClickPlugin.TAG_PAGE) && packageName!=null && !packageName.equals("")){
+				attrValue = packageName + "." + attrValue;
+			}
+			
+			if(attrName.equals(ClickPlugin.ATTR_CLASSNAME)){
+				if(!existsJavaClass(file, attrValue)){
+					createWarningMarker(file, "notExist", new String[]{attrValue}, start, length);
+				}
+			}
+		}
+		
+		// automapping and package of <pages>
+		if(tagName.equals(ClickPlugin.TAG_PAGES)){
+			if(attrName.equals(ClickPlugin.ATTR_AUTO_MAPPING)){
+				if(!containsValue(ClickPlugin.BOOLEAN_VALUES, attrValue)){
+					createWarningMarker(file, "autoMapping", new String[0], start, length);
+				}
+			} else if(attrName.equals(ClickPlugin.ATTR_AUTO_BINDING)){
+				if(!containsValue(ClickPlugin.AUTO_BINDING_VALUES, attrValue)){
+					createWarningMarker(file, "autoBinding", new String[0], start, length);
+				}
+			} else if(attrName.equals(ClickPlugin.ATTR_PACKAGE)){
+				
+			}
+		}
+		// path of <page>
+		if(tagName.equals(ClickPlugin.TAG_PAGE)){
+			if(attrName.equals(ClickPlugin.ATTR_PATH)){
+				
+			}
+		}
+		// type of <header>
+		if(tagName.equals(ClickPlugin.TAG_HEADER)){
+			if(attrName.equals(ClickPlugin.ATTR_TYPE)){
+				if(!containsValue(ClickPlugin.HEADER_TYPE_VALUES, attrValue)){
+					createWarningMarker(file, "headerType", new String[0], start, length);
+				}
+			}
+		}
+		// value and logto of <mode>
+		if(tagName.equals(ClickPlugin.TAG_MODE)){
+			if(attrName.equals(ClickPlugin.ATTR_VALUE)){
+				if(!containsValue(ClickPlugin.MODE_VALUES, attrValue)){
+					createWarningMarker(file, "modeValue", new String[0], start, length);
+				}
+			}
+		}
+		// charset of <click-app>
+		if(tagName.equals(ClickPlugin.TAG_CLICK_APP)){
+			if(attrName.equals(ClickPlugin.ATTR_CHARSET)){
+				if(!isSupportedEncoding(attrValue)){
+					createWarningMarker(file, "unsupportedEncoding", new String[]{attrValue}, start, length);
+				}
+			}
+		}
+	}
+	
+	private boolean existsJavaClass(IFile file, String typename){
+		IJavaProject project = JavaCore.create(file.getProject());
+		boolean exist = false;
+		try {
+			IType type = project.findType(typename);
+			exist = type.exists();
+		} catch(Exception ex){
+			exist = false;
+		}
+		return exist;
+	}
+	
+	private boolean containsValue(String[] proposals, String value){
+		for(int i=0;i<proposals.length;i++){
+			if(proposals[i].equals(value)){
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	private boolean isSupportedEncoding(String encoding){
+		try {
+			new String(new byte[0], encoding);
+		} catch(UnsupportedEncodingException ex){
+			return false;
+		}
+		return true;
+	}
+	
+	/**
+	 * Create the warning marker.
+	 */
+	private void createWarningMarker(IFile file, String key, Object[] values, 
+			int start, int length){
+		try {
+			String message = resource.getString(key);
+			message = MessageFormat.format(message, values);
+			
+			IMarker marker = file.createMarker(IMarker.PROBLEM);
+			Map<String, Object> map = new HashMap<String, Object>();
+			map.put(IMarker.SEVERITY, new Integer(IMarker.SEVERITY_WARNING));
+			map.put(IMarker.MESSAGE, message);
+//			map.put(IMarker.LINE_NUMBER,new Integer(line));
+			map.put(IMarker.CHAR_START,new Integer(start));
+			map.put(IMarker.CHAR_END,new Integer(start + length));
+			marker.setAttributes(map);
+			
+		} catch(Exception e){
+			ClickPlugin.log(e);
+		}
+	}	
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/config/DefaultClickConfigurationProvider.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/config/DefaultClickConfigurationProvider.java
new file mode 100644
index 0000000..0836d5a
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/config/DefaultClickConfigurationProvider.java
@@ -0,0 +1,312 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.config;
+
+import java.util.StringTokenizer;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+
+/**
+ * A default implementation of <code>IClickConfigurationProvider</code>.
+ * 
+ * @author Naoki Takezoe
+ */
+public class DefaultClickConfigurationProvider implements IClickConfigurationProvider {
+
+	/**
+	 * Returns the status of the auto mapping in the specified project.
+	 * <p>
+	 * <strong>Note:</strong> The auto-mapping mode has been available 
+	 * in default since Click 1.1.
+	 * 
+	 * @param project the project
+	 * @return true if the auto mapping is enable; false otherwise
+	 */
+	public boolean getAutoMapping(IProject project) {
+		IStructuredModel model = ClickUtils.getClickXMLModel(project);
+		try {
+			NodeList list = (((IDOMModel)model).getDocument()).getElementsByTagName(ClickPlugin.TAG_PAGES);
+			if(list.getLength()==1){
+				Element pages = (Element)list.item(0);
+				if(pages.hasAttribute(ClickPlugin.ATTR_PACKAGE)){
+					String autoMapping = pages.getAttribute(ClickPlugin.ATTR_AUTO_MAPPING);
+					if("false".equals(autoMapping)){
+						return false;
+					}
+					return true;
+				}
+			}
+		} catch(Exception ex){
+		} finally {
+			if(model!=null){
+				model.releaseFromRead();
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Returns the charset which is defined in <tt>click.xml</tt>.
+	 * If <tt>click.xml</tt> doesn't has the charset, returns <code>null</code>.
+	 * 
+	 * @param project the project
+	 * @return the charset
+	 */
+	public String getCharset(IProject project) {
+		IStructuredModel model = ClickUtils.getClickXMLModel(project);
+		String charset = null;
+		try {
+			NodeList list = (((IDOMModel)model).getDocument()).getElementsByTagName(ClickPlugin.TAG_CLICK_APP);
+			if(list.getLength()==1){
+				Element format = (Element)list.item(0);
+				charset = format.getAttribute(ClickPlugin.ATTR_CHARSET);
+			}
+		} catch(Exception ex){
+		} finally {
+			if(model!=null){
+				model.releaseFromRead();
+			}
+		}
+		return charset;
+	}
+
+	/**
+	 * Returns the full qualified classname of the page class
+	 * which paired to the specified HTML file.
+	 * 
+	 * @param project the project
+	 * @param htmlName the HTML file path 
+	 * @return the full qulified classname.
+	 *   If unable to find the paired class, returns <code>null</code>.
+	 */
+	public String getClassfromHTML(IProject project, String htmlName) {
+		
+		String packageName = getPagePackageName(project);
+		
+		IStructuredModel model = ClickUtils.getClickXMLModel(project);
+		try {
+			if(model != null){
+				NodeList list = (((IDOMModel)model).getDocument()).getElementsByTagName(ClickPlugin.TAG_PAGE);
+				for(int i=0;i<list.getLength();i++){
+					Element element = (Element)list.item(i);
+					String path = element.getAttribute(ClickPlugin.ATTR_PATH);
+					if(path!=null && path.equals(htmlName)){
+						String className = element.getAttribute(ClickPlugin.ATTR_CLASSNAME);
+						if(className!=null && className.length()>0 && 
+								packageName!=null && packageName.length()>0){
+							className = packageName + "." + className;
+						}
+						return className;
+					}
+				}
+			}
+			
+			if(getAutoMapping(project) && packageName!=null && packageName.length()>0){
+				
+				String className = "";
+				
+		        if (htmlName.indexOf("/") != -1) {
+		            StringTokenizer tokenizer = new StringTokenizer(htmlName, "/");
+		            while (tokenizer.hasMoreTokens()) {
+		                String token = tokenizer.nextToken();
+		                if (tokenizer.hasMoreTokens()) {
+		                	if(packageName.length()!=0){
+		                		packageName += ".";
+		                	}
+		                    packageName = packageName + token;
+		                } else {
+		                    className = token.replaceFirst("\\.htm$", "");
+		                }
+		            }
+		        } else {
+		            className = htmlName.substring(0, htmlName.lastIndexOf('.'));
+		        }
+		        
+		        StringTokenizer tokenizer = new StringTokenizer(className, "_-");
+		        className = "";
+		        while (tokenizer.hasMoreTokens()) {
+		            String token = tokenizer.nextToken();
+		            token = Character.toUpperCase(token.charAt(0)) + token.substring(1);
+		            className += token;
+		        }
+
+		        className = packageName + "." + className;
+		        
+		        return className;
+			}
+			
+		} catch(Exception ex){
+			ClickPlugin.log(ex);
+		} finally {
+			if(model!=null){
+				model.releaseFromRead();
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Returns <code>IType</code> of the format object which is specified in <tt>click.xml</tt>.
+	 * If format element is not defined, this method returns <code>net.sf.click.util.Format</code>.
+	 * 
+	 * @param project the project
+	 * @return IType of the format object
+	 */
+	public IType getFormat(IProject project) {
+		IStructuredModel model = ClickUtils.getClickXMLModel(project);
+		IJavaProject javaProject = JavaCore.create(project);
+		IType formatType = null;
+		try {
+			if(model == null){
+				return javaProject.findType(ClickUtils.DEFAULT_FORMAT_CLASS);
+			}
+			NodeList list = (((IDOMModel)model).getDocument()).getElementsByTagName(ClickPlugin.TAG_FORMAT);
+			String className = null;
+			if(list.getLength()==1){
+				Element format = (Element)list.item(0);
+				className = format.getAttribute(ClickPlugin.ATTR_CLASSNAME);
+			}
+			if(className==null){
+				className = ClickUtils.DEFAULT_FORMAT_CLASS;
+			}
+			formatType = javaProject.findType(className);
+		} catch(Exception ex){
+		} finally {
+			if(model!=null){
+				model.releaseFromRead();
+			}
+		}
+		return formatType;
+	}
+
+	/**
+	 * Returns the the HTML file path which paired to the specified class.
+	 *  
+	 * @param project the project
+	 * @param className the classname
+	 * @return the HTML file path.
+	 *     If unable to find the paired HTML, returns <code>null</code>.
+	 */
+	public String getHTMLfromClass(IProject project, String className) {
+		String packageName = getPagePackageName(project);
+		IStructuredModel model = ClickUtils.getClickXMLModel(project);
+		try {
+			if(model != null){
+				NodeList list = (((IDOMModel)model).getDocument()).getElementsByTagName(ClickPlugin.TAG_PAGE);
+				for(int i=0;i<list.getLength();i++){
+					Element element = (Element)list.item(i);
+					String clazz = element.getAttribute(ClickPlugin.ATTR_CLASSNAME);
+					if(clazz!=null){
+						if(packageName!=null && packageName.length()>0){
+							clazz = packageName + "." + clazz;
+						}
+						if(clazz.equals(className)){
+							return element.getAttribute(ClickPlugin.ATTR_PATH);
+						}
+					}
+				}
+			}
+			
+			if(getAutoMapping(project) && packageName!=null && packageName.length()>0){
+				String root = ClickUtils.getWebAppRootFolder(project);
+				if(className.startsWith(packageName + ".")){
+					String dir = null;
+					String path = className.substring(packageName.length() + 1);
+					
+					path = path.replaceAll("\\.", "/");
+					
+					int index = path.lastIndexOf('/');
+					if(index >= 0){
+						dir =  path.substring(0, index);
+						path = path.substring(index + 1);;
+					}
+					path = path.replaceFirst("Page$", "");
+					String[] templateProposals = ClickUtils.getTempleteProposals(path);
+					
+					IFolder folder = project.getFolder(root);
+					for(int i=0;i<templateProposals.length;i++){
+						IResource resource = null;
+						if(dir!=null){
+							templateProposals[i] = dir + "/" + templateProposals[i];
+						}
+						resource = folder.findMember(templateProposals[i]);
+						if(resource!=null && resource.exists() && resource instanceof IFile){
+							return templateProposals[i];
+						}
+					}
+				}
+			}
+
+		} catch(Exception ex){
+			ClickPlugin.log(ex);
+		} finally {
+			if(model!=null){
+				model.releaseFromRead();
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Returns the package name of page classes which is specified in <tt>click.xml</tt>.
+	 * If the package name is not specified, thie method returns <code>null</code>.
+	 * 
+	 * @param project the project
+	 * @return the package name of page classes or <code>null</code>
+	 */
+	public String getPagePackageName(IProject project) {
+		IStructuredModel model = ClickUtils.getClickXMLModel(project);
+		try {
+			NodeList list = (((IDOMModel)model).getDocument()).getElementsByTagName(ClickPlugin.TAG_PAGES);
+			if(list.getLength()==1){
+				Element pages = (Element)list.item(0);
+				if(pages.hasAttribute(ClickPlugin.ATTR_PACKAGE)){
+					return pages.getAttribute(ClickPlugin.ATTR_PACKAGE);
+				}
+			}
+		} catch(Exception ex){
+		} finally {
+			if(model!=null){
+				model.releaseFromRead();
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * This method always returns <code>true</code>.
+	 */
+	public boolean isSupportedProject(IProject project) {
+		return true;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/config/IClickConfigurationProvider.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/config/IClickConfigurationProvider.java
new file mode 100644
index 0000000..76d4078
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/config/IClickConfigurationProvider.java
@@ -0,0 +1,77 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.config;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.jdt.core.IType;
+
+/**
+ * Provides framework configurations.
+ * 
+ * @author Naoki Takezoe
+ */
+public interface IClickConfigurationProvider {
+	
+	/**
+	 * Returns the charset.
+	 * 
+	 * @param project the project
+	 * @return the charset
+	 */
+	public String getCharset(IProject project);
+	
+	/**
+	 * Returns the format class.
+	 * 
+	 * @param project the project
+	 * @return the format class
+	 */
+	public IType getFormat(IProject project);
+	
+	public boolean getAutoMapping(IProject project);
+	
+	/**
+	 * Returns the root package name which contains page classes.
+	 * 
+	 * @param project the project
+	 * @return the root package name of page classes
+	 */
+	public String getPagePackageName(IProject project);
+	
+	/**
+	 * Returns the HTML template path from the page classname.
+	 * 
+	 * @param project the project
+	 * @param className the page classname
+	 * @return the HTML template path
+	 */
+	public String getHTMLfromClass(IProject project, String className);
+	
+	/**
+	 * Returns the page classname from the HTML template path.
+	 * 
+	 * @param project the project
+	 * @param htmlName the HTML template path
+	 * @return the page classname
+	 */
+	public String getClassfromHTML(IProject project, String htmlName);
+	
+	public boolean isSupportedProject(IProject project);
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetInstallDataModelProvider.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetInstallDataModelProvider.java
new file mode 100644
index 0000000..fec7be2
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetInstallDataModelProvider.java
@@ -0,0 +1,61 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.facet;
+
+import java.util.Set;
+
+import org.eclipse.wst.common.componentcore.datamodel.FacetInstallDataModelProvider;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickFacetInstallDataModelProvider extends FacetInstallDataModelProvider {
+	
+	public static final String ROOT_PACKAGE = "rootPackage";
+	public static final String USE_SPRING = "useSpring";
+	public static final String USE_CAYENNE = "useCayenne";
+	public static final String USE_PERFORMANCE_FILTER = "usePerformanceFilter";
+	
+	public Set<String> getPropertyNames() {
+		@SuppressWarnings("unchecked")
+		Set<String> names = super.getPropertyNames();
+		names.add(USE_SPRING);
+		names.add(USE_CAYENNE);
+		names.add(USE_PERFORMANCE_FILTER);
+		names.add(ROOT_PACKAGE);
+		return names;
+	}
+
+	public Object getDefaultProperty(String propertyName) {
+		if (propertyName.equals(FACET_ID)) {
+			return "click";
+		} else if(propertyName.equals(USE_SPRING)){
+			return new Boolean(false);
+		} else if(propertyName.equals(USE_CAYENNE)){
+			return new Boolean(false);
+		} else if(propertyName.equals(USE_PERFORMANCE_FILTER)){
+			return new Boolean(false);
+		} else if(propertyName.equals(ROOT_PACKAGE)){
+			return "";
+		}
+		return super.getDefaultProperty(propertyName);
+	}
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetInstallDelegate.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetInstallDelegate.java
new file mode 100644
index 0000000..7e2b074
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetInstallDelegate.java
@@ -0,0 +1,405 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.facet;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.core.builder.ClickProjectNature;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jst.j2ee.common.CommonFactory;
+import org.eclipse.jst.j2ee.common.Listener;
+import org.eclipse.jst.j2ee.common.ParamValue;
+import org.eclipse.jst.j2ee.internal.J2EEVersionConstants;
+import org.eclipse.jst.j2ee.web.componentcore.util.WebArtifactEdit;
+import org.eclipse.jst.j2ee.webapplication.Filter;
+import org.eclipse.jst.j2ee.webapplication.FilterMapping;
+import org.eclipse.jst.j2ee.webapplication.InitParam;
+import org.eclipse.jst.j2ee.webapplication.Servlet;
+import org.eclipse.jst.j2ee.webapplication.WebApp;
+import org.eclipse.jst.j2ee.webapplication.WebapplicationFactory;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.project.facet.core.IDelegate;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+import org.eclipse.wst.html.internal.validation.HTMLValidator;
+import org.eclipse.wst.validation.internal.ConfigurationManager;
+import org.eclipse.wst.validation.internal.ProjectConfiguration;
+import org.eclipse.wst.validation.internal.ValidatorMetaData;
+
+/**
+ * Installs the click facet.
+ * <ol>
+ *   <li>Copies click-x.x.jar and click-extras-x.x.jar into WEB-INF/lib.</li>
+ *   <li>Copies click.xml into WEB-INF.</li>
+ *   <li>Adds servlet and servlet-mapping to web.xml.</li>
+ *   <li>Adds <code>ClickProjectNature</code> to the project.</li>
+ * </ol>
+ * @author Naoki Takezoe
+ */
+@SuppressWarnings("unchecked")
+public class ClickFacetInstallDelegate implements IDelegate {
+
+	public void execute(IProject project, IProjectFacetVersion fv,
+			Object cfg, IProgressMonitor monitor) throws CoreException {
+		try {
+			IDataModel config = null;
+			if (cfg != null) {
+				config = (IDataModel) cfg;
+			}
+
+			if (monitor != null) {
+				int totalTasks = 3;
+				if(config.getBooleanProperty(ClickFacetInstallDataModelProvider.USE_SPRING)){
+					totalTasks++;
+				}
+				if(config.getBooleanProperty(ClickFacetInstallDataModelProvider.USE_CAYENNE)){
+					totalTasks++;
+				}
+				monitor.beginTask("", totalTasks); //$NON-NLS-1$
+			}
+
+			// Add Click JARs to WEB-INF/lib
+			deployClickFiles(project, config, monitor);
+
+			// Update web model
+			createServletAndModifyWebXML(project, config, monitor,
+					config.getBooleanProperty(ClickFacetInstallDataModelProvider.USE_SPRING),
+					config.getBooleanProperty(ClickFacetInstallDataModelProvider.USE_CAYENNE),
+					config.getBooleanProperty(ClickFacetInstallDataModelProvider.USE_PERFORMANCE_FILTER));
+
+			if (monitor != null) {
+				monitor.worked(1);
+			}
+
+			// Add the nature
+			ClickProjectNature.addNatute(project);
+
+			if (monitor != null) {
+				monitor.worked(1);
+			}
+
+			// Disable HTML validator
+			try {
+				ProjectConfiguration projectConfig
+					= ConfigurationManager.getManager().getProjectConfiguration(project);
+				ValidatorMetaData[] meta = projectConfig.getValidators();
+				List enables = new ArrayList();
+				for(int i=0;i<meta.length;i++){
+					if(!meta[i].getValidatorUniqueName().equals(HTMLValidator.class.getName())){
+						enables.add(meta[i]);
+					}
+				}
+				projectConfig.setDoesProjectOverride(true);
+
+				projectConfig.setEnabledManualValidators(
+						(ValidatorMetaData[])enables.toArray(new ValidatorMetaData[enables.size()]));
+				projectConfig.setEnabledBuildValidators(
+						(ValidatorMetaData[])enables.toArray(new ValidatorMetaData[enables.size()]));
+
+			} catch(Exception ex){
+				//ex.printStackTrace();
+			}
+			if (monitor != null) {
+				monitor.worked(1);
+			}
+
+			// Install Spring
+			if(config.getBooleanProperty(ClickFacetInstallDataModelProvider.USE_SPRING)){
+				deploySpringFiles(project, config, monitor);
+				if (monitor != null) {
+					monitor.worked(1);
+				}
+			}
+
+			// Install Cayenne
+			if(config.getBooleanProperty(ClickFacetInstallDataModelProvider.USE_CAYENNE)){
+				deployCayenneFiles(project, config, monitor);
+				if (monitor != null) {
+					monitor.worked(1);
+				}
+			}
+
+			project.refreshLocal(IProject.DEPTH_INFINITE, monitor);
+
+		} finally {
+			if (monitor != null) {
+				monitor.done();
+			}
+		}
+	}
+
+	/**
+	 * Deploy Spring JARs into <tt>WEB-INF/lib</tt>.
+	 */
+	private void deploySpringFiles(IProject project, IDataModel config,
+			IProgressMonitor monitor) throws JavaModelException {
+		IPath destPath = project.getLocation().append(ClickFacetUtil.getWebContentPath(project));
+		File webInf = destPath.append("WEB-INF").toFile();
+
+		for(int i=0;i<ClickFacetUtil.SPRING_LIBS.length;i++){
+			try {
+				File file = new File(webInf, ClickFacetUtil.SPRING_LIBS[i]);
+				URL url = ClickPlugin.getDefault().getBundle().getEntry(
+						ClickFacetUtil.SPRING_DIR + ClickFacetUtil.SPRING_LIBS[i]);
+				ClickUtils.copyStream(url.openStream(), new FileOutputStream(file));
+			} catch(Exception ex){
+				ClickPlugin.log(ex);
+			}
+		}
+
+		File file = new File(webInf, "spring-beans.xml");
+		try {
+			if(!file.exists()){
+				file.createNewFile();
+			}
+			
+			URL url = ClickPlugin.getDefault().getBundle().getEntry(
+					ClickFacetUtil.SPRING_DIR + "/spring-beans.xml");
+			
+			// Replaces ${rootPackage} by the input package name.
+			String contents = ClickUtils.readStream(url.openStream());
+			contents = contents.replace("${rootPackage}", 
+					config.getStringProperty(ClickFacetInstallDataModelProvider.ROOT_PACKAGE));
+			
+			ClickUtils.copyStream(new ByteArrayInputStream(contents.getBytes("UTF-8")), 
+					new FileOutputStream(file));
+			
+		} catch(Exception ex){
+			ClickPlugin.log(ex);
+		}
+	}
+
+	/**
+	 * Deploy Cayenne JARs into <tt>WEB-INF/lib</tt>.
+	 */
+	private void deployCayenneFiles(IProject project, IDataModel config,
+			IProgressMonitor monitor) throws JavaModelException {
+		IPath destPath = project.getLocation().append(ClickFacetUtil.getWebContentPath(project));
+		File webInf = destPath.append("WEB-INF").toFile();
+
+		for(int i=0;i<ClickFacetUtil.CAYENNE_LIBS.length;i++){
+			try {
+				File file = new File(webInf, ClickFacetUtil.CAYENNE_LIBS[i]);
+				URL url = ClickPlugin.getDefault().getBundle().getEntry(
+						ClickFacetUtil.CAYENNE_DIR + ClickFacetUtil.CAYENNE_LIBS[i]);
+				ClickUtils.copyStream(url.openStream(), new FileOutputStream(file));
+			} catch(Exception ex){
+				ClickPlugin.log(ex);
+			}
+		}
+
+		IJavaProject javaProject = JavaCore.create(project);
+		IPackageFragmentRoot[] roots = javaProject.getPackageFragmentRoots();
+		for(int i=0;i<roots.length;i++){
+			if(roots[i].getResource() instanceof IFolder){
+				IFile file = ((IFolder) roots[i].getResource()).getFile("cayenne.xml");
+				try {
+					file.create(ClickPlugin.getDefault().getBundle().getEntry(
+							ClickFacetUtil.CAYENNE_DIR + "/cayenne.xml").openStream(),
+							true, monitor);
+				} catch(Exception ex){
+					ClickPlugin.log(ex);
+				}
+				break;
+			}
+		}
+	}
+
+	private void deployClickFiles(IProject project, IDataModel config, IProgressMonitor monitor) {
+		IPath destPath = project.getLocation().append(ClickFacetUtil.getWebContentPath(project));
+		File webInf = destPath.append("WEB-INF").toFile();
+		for(int i=0;i<ClickFacetUtil.COPY_FILES.length;i++){
+			try {
+				File file = new File(webInf, ClickFacetUtil.COPY_FILES[i]);
+				if(!file.exists() && checkOldFile(file)){
+					file.createNewFile();
+				} else {
+					continue;
+				}
+
+				URL url = ClickPlugin.getDefault().getBundle().getEntry(
+						ClickFacetUtil.CLICK_DIR + ClickFacetUtil.COPY_FILES[i]);
+				if(file.getName().equals("click.xml")){
+					// Replaces ${rootPackage} by the input package name.
+					String contents = ClickUtils.readStream(url.openStream());
+					contents = contents.replace("${rootPackage}", 
+							config.getStringProperty(ClickFacetInstallDataModelProvider.ROOT_PACKAGE));
+					
+					ClickUtils.copyStream(new ByteArrayInputStream(contents.getBytes("UTF-8")), 
+							new FileOutputStream(file));
+					
+				} else {
+					ClickUtils.copyStream(url.openStream(), new FileOutputStream(file));
+				}
+			} catch(Exception ex){
+				ClickPlugin.log(ex);
+			}
+		}
+	}
+
+	/**
+	 * Checkes whether the old version of the given file exists.
+	 */
+	private boolean checkOldFile(File file){
+		String name = file.getName();
+		if(name.startsWith("click-") && name.endsWith(".jar")){
+			int index = name.lastIndexOf('-');
+			if(index > 0){
+				String begin = name.substring(0, index+1);
+				File parent = file.getParentFile();
+				File[] files = parent.listFiles();
+				for(int i=0;i<files.length;i++){
+					String fileName = files[i].getName();
+					if(files[i].isFile() && fileName.startsWith(begin) && fileName.endsWith(".jar")){
+						return false;
+					}
+				}
+			}
+		}
+		return true;
+	}
+
+	private void createServletAndModifyWebXML(
+			IProject project, final IDataModel config,IProgressMonitor monitor, 
+			boolean useSpring, boolean useCayenne, boolean usePerformanceFilter) {
+
+		WebApp webApp = null;
+		WebArtifactEdit artifactEdit = null;
+		try {
+			artifactEdit = ClickUtils.getWebArtifactEditForWrite(project);
+			webApp = artifactEdit.getWebApp();
+
+			// create or update servlet ref
+			Servlet servlet = ClickUtils.findClickServlet(webApp, useSpring);
+			if (servlet != null) {
+				// remove old mappings
+				ClickUtils.removeURLMappings(webApp, servlet);
+			}
+
+			servlet = ClickUtils.createOrUpdateServletRef(webApp, config, servlet, useSpring);
+			
+			if(useSpring){
+				ParamValue contextParam = CommonFactory.eINSTANCE.createParamValue();
+				contextParam.setName("contextConfigLocation");
+				contextParam.setValue("WEB-INF/spring-beans.xml");
+				webApp.getContextParams().add(contextParam);
+				
+				Listener listener = CommonFactory.eINSTANCE.createListener();
+				listener.setListenerClassName("org.springframework.web.context.ContextLoaderListener");
+				webApp.getListeners().add(listener);
+			}
+			
+			// Add PerformanceFilter
+			if(usePerformanceFilter){
+				Filter filter = WebapplicationFactory.eINSTANCE.createFilter();
+				filter.setName("PerformanceFilter");
+				filter.setFilterClassName("org.apache.click.extras.filter.PerformanceFilter");
+				
+				if (webApp.getJ2EEVersionID() >= J2EEVersionConstants.J2EE_1_4_ID) {
+					// J2EE 1.4
+					ParamValue initParam = CommonFactory.eINSTANCE.createParamValue();
+					initParam.setName("cachable-paths");
+					initParam.setValue("/assets/*");
+					filter.getInitParamValues().add(initParam);
+				} else {
+					// J2EE 1.2 or 1.3
+					InitParam initParam = WebapplicationFactory.eINSTANCE.createInitParam();
+					initParam.setParamName("cachable-paths");
+					initParam.setParamValue("/assets/*");
+					filter.getInitParams().add(initParam);
+				}
+				
+				webApp.getFilters().add(filter);
+
+				FilterMapping mapping = WebapplicationFactory.eINSTANCE.createFilterMapping();
+				mapping.setServletName(servlet.getServletName());
+				mapping.setFilter(filter);
+				webApp.getFilterMappings().add(mapping);
+				
+				String[] filterPatterns = {"*.css", "*.js", "*.gif", "*.png"};
+				for(String pattern: filterPatterns){
+					mapping = WebapplicationFactory.eINSTANCE.createFilterMapping();
+					mapping.setFilter(filter);
+					mapping.setUrlPattern(pattern);
+					webApp.getFilterMappings().add(mapping);
+				}
+			}
+			
+			// init mappings
+			String[] listOfMappings = {"*.htm"};
+			ClickUtils.setUpURLMappings(webApp, listOfMappings, servlet);
+
+			// welcome-file-list
+			ClickUtils.createOrUpdateFilelist(webApp);
+
+			// Add Cayenne Support
+			if(useCayenne){
+				Filter filter = WebapplicationFactory.eINSTANCE.createFilter();
+				filter.setFilterClassName(ClickUtils.CAYENNE_FILTER_CLASS);
+				filter.setName("DataContextFilter");
+
+				if (webApp.getJ2EEVersionID() >= J2EEVersionConstants.J2EE_1_4_ID) {
+					// J2EE 1.4
+					ParamValue initParam = CommonFactory.eINSTANCE.createParamValue();
+					initParam.setName("session-scope");
+					initParam.setValue("false");
+					filter.getInitParamValues().add(initParam);
+				} else {
+					// J2EE 1.2 or 1.3
+					InitParam initParam = WebapplicationFactory.eINSTANCE.createInitParam();
+					initParam.setParamName("session-scope");
+					initParam.setParamValue("false");
+					filter.getInitParams().add(initParam);
+				}
+
+				webApp.getFilters().add(filter);
+
+				FilterMapping mapping = WebapplicationFactory.eINSTANCE.createFilterMapping();
+				mapping.setServletName(servlet.getServletName());
+				mapping.setFilter(filter);
+				webApp.getFilterMappings().add(mapping);
+			}
+		} catch(Exception ex){
+			ClickPlugin.log(ex);
+		} finally {
+			if (artifactEdit != null) {
+				// save and dispose
+				artifactEdit.saveIfNecessary(monitor);
+				artifactEdit.dispose();
+			}
+
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetUninstallDelegate.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetUninstallDelegate.java
new file mode 100644
index 0000000..7a5ea3e
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetUninstallDelegate.java
@@ -0,0 +1,170 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.facet;
+
+import java.io.File;
+import java.util.List;
+
+
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.core.builder.ClickProjectNature;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.jst.j2ee.web.componentcore.util.WebArtifactEdit;
+import org.eclipse.jst.j2ee.webapplication.Filter;
+import org.eclipse.jst.j2ee.webapplication.Servlet;
+import org.eclipse.jst.j2ee.webapplication.WebApp;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.project.facet.core.IDelegate;
+import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
+
+/**
+ * Uninstalls the click facet.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickFacetUninstallDelegate implements IDelegate {
+
+	public void execute(IProject project, IProjectFacetVersion fv, 
+			Object config, IProgressMonitor monitor) throws CoreException {
+		
+		IDataModel dataModel = (IDataModel) config;
+		
+		if (monitor != null) {
+			monitor.beginTask("", 3); //$NON-NLS-1$
+		}
+		
+		removeClickFiles(project, dataModel, monitor);
+		monitor.worked(1);
+		
+		// Removes the nature
+		ClickProjectNature.removeNature(project);
+		if (monitor != null) {
+			monitor.worked(1);
+		}
+		
+		try {
+			// Removes the facet
+			uninstallClickReferencesFromWebApp(project, dataModel, monitor);
+
+			if (monitor != null) {
+				monitor.worked(1);
+			}
+		} finally {
+			if (monitor != null) {
+				monitor.done();
+			}
+		}	
+	}
+	
+	protected void removeClickFiles(IProject project, IDataModel config, IProgressMonitor monitor) {
+		IPath destPath = project.getLocation().append(ClickFacetUtil.getWebContentPath(project));
+		
+		File webInf = destPath.append("WEB-INF").toFile();
+		// remove Click files
+		for(int i=0;i<ClickFacetUtil.COPY_FILES.length;i++){
+			File file = new File(webInf, ClickFacetUtil.COPY_FILES[i]);
+			if(file.exists()){
+				file.delete();
+			}
+		}
+		
+		// remove Spring files
+		for(int i=0;i<ClickFacetUtil.SPRING_LIBS.length;i++){
+			File file = new File(webInf, ClickFacetUtil.SPRING_LIBS[i]);
+			if(file.exists()){
+				file.delete();
+			}
+		}
+		
+		// remove Cayenne files
+		for(int i=0;i<ClickFacetUtil.CAYENNE_LIBS.length;i++){
+			File file = new File(webInf, ClickFacetUtil.CAYENNE_LIBS[i]);
+			if(file.exists()){
+				file.delete();
+			}
+		}
+	}
+	
+	private void uninstallClickReferencesFromWebApp(IProject project, 
+			IDataModel config, IProgressMonitor monitor) {
+		WebArtifactEdit artifactEdit = ClickUtils.getWebArtifactEditForWrite(project);
+		WebApp webApp = artifactEdit.getWebApp();
+
+		try {
+			Servlet servlet = ClickUtils.findClickServlet(webApp, false);
+			if (servlet == null){
+				servlet = ClickUtils.findClickServlet(webApp, true);
+				if(servlet == null){
+					return;
+				}
+			}
+			// remove faces url mappings
+			removeClickURLMappings(webApp, servlet);
+			
+			// remove Cayenne filter
+			removeCayenneFilter(webApp);
+			
+			// remove servlet
+			removeClickServlet(webApp, servlet);
+
+		} finally {
+			if (artifactEdit != null) {
+				artifactEdit.saveIfNecessary(monitor);
+				artifactEdit.dispose();
+			}
+		}
+	}
+	
+	private void removeCayenneFilter(WebApp webApp){
+		@SuppressWarnings("unchecked")
+		List filters = webApp.getFilters();
+		
+		Filter cayenneFilter = null;
+		for(int i=0;i<filters.size();i++){
+			Filter filter = (Filter) filters.get(i);
+			if(filter.getFilterClassName().equals(ClickUtils.CAYENNE_FILTER_CLASS)){
+				cayenneFilter = filter;
+				break;
+			}
+		}
+		if(cayenneFilter != null){
+			while (webApp.getFilterMapping(cayenneFilter) != null) {
+				webApp.getFilterMappings().remove(
+						webApp.getFilterMapping(cayenneFilter));
+			}
+		}
+		
+		webApp.getFilters().remove(cayenneFilter);
+	}
+	
+	private void removeClickURLMappings(WebApp webApp, Servlet servlet) {
+		while (webApp.getServletMapping(servlet) != null) {
+			webApp.getServletMappings().remove(
+					webApp.getServletMapping(servlet));
+		}
+	}
+	
+	private void removeClickServlet(WebApp webApp, Servlet servlet) {
+		webApp.getServlets().remove(servlet);
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetUtil.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetUtil.java
new file mode 100644
index 0000000..13caf85
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickFacetUtil.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.facet;
+
+
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.Path;
+
+/**
+ * Provides constants and utility methods about the project facet.
+ *
+ * @author Naoki Takezoe
+ * @since 1.6.0
+ */
+public class ClickFacetUtil {
+
+	public static String CLICK_DIR = "click-2.1.0";
+	public static String CAYENNE_DIR = "cayenne-3.0M6";
+	public static String SPRING_DIR = "spring-2.5.6";
+
+	public static final String[] COPY_FILES = {
+		"/lib/click-2.1.0.jar",
+		"/lib/click-extras-2.1.0.jar",
+		"/click.xml",
+	};
+
+	public static final String[] CAYENNE_LIBS = {
+		"/lib/ashwood-2.0.jar",
+		"/lib/cayenne-server-3.0M6.jar",
+		"/lib/commons-logging-1.1.1.jar",
+	};
+
+	public static final String[] SPRING_LIBS = {
+		"/lib/spring-2.5.6.jar",
+		"/lib/commons-logging-1.1.1.jar",
+	};
+
+	public static IPath getWebContentPath(IProject project) {
+		return new Path(ClickUtils.getWebAppRootFolder(project));
+	}
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickOldFacetUninstallDelegate.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickOldFacetUninstallDelegate.java
new file mode 100644
index 0000000..c37170f
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/facet/ClickOldFacetUninstallDelegate.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.facet;
+
+import java.io.File;
+
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+
+
+/**
+ * <code>UninstallDelegate</code> for old facets.
+ * 
+ * @author Naoki Takezoe
+ * @since 1.6.0
+ * @deprecated
+ */
+public class ClickOldFacetUninstallDelegate extends ClickFacetUninstallDelegate {
+
+	protected void removeClickFiles(IProject project, IDataModel config, IProgressMonitor monitor) {
+		IPath destPath = project.getLocation().append(ClickFacetUtil.getWebContentPath(project));
+		
+		File webInf = destPath.append("WEB-INF").toFile();
+		File libDir = new File(webInf, "lib");
+		File[] files = libDir.listFiles();
+		
+		// removes JAR files
+		for(int i=0;i<files.length;i++){
+			String name = files[i].getName();
+			if(files[i].isFile() && name.startsWith("click-") && name.endsWith(".jar")){
+				files[i].delete();
+			}
+		}
+		
+		// removes click.xml
+		File clickXml = new File(webInf, "click.xml");
+		if(clickXml.exists()){
+			clickXml.delete();
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/TemplateValidator.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/TemplateValidator.java
new file mode 100644
index 0000000..42b753f
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/TemplateValidator.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.validator;
+
+import java.io.InputStreamReader;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.velocity.runtime.RuntimeInstance;
+import org.apache.velocity.runtime.parser.ParseException;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.wst.validation.internal.core.ValidationException;
+import org.eclipse.wst.validation.internal.provisional.core.IReporter;
+import org.eclipse.wst.validation.internal.provisional.core.IValidationContext;
+import org.eclipse.wst.validation.internal.provisional.core.IValidator;
+
+/**
+ * The <code>IValidator</code> implementation for Click Page Templates.
+ * <p>
+ * This class provides Velocity syntax checking.
+ * 
+ * @author Naoki Takezoe
+ */
+public class TemplateValidator implements IValidator {
+	
+	private static Pattern PATTERN = Pattern.compile(" at line ([0-9]+?),");
+	
+	public void cleanup(IReporter reporter) {
+	}
+
+	public void validate(IValidationContext helper, IReporter reporter) throws ValidationException {
+		String[] uris = helper.getURIs();
+		reporter.removeAllMessages(this);
+		if (uris != null) {
+			for (int i = 0; i < uris.length && !reporter.isCancelled(); i++) {
+				IFile file = ResourcesPlugin.getWorkspace().getRoot().getFile(new Path(uris[i]));
+				try {
+					try {
+						RuntimeInstance runtime = new RuntimeInstance();
+						runtime.init();
+						runtime.parse(new InputStreamReader(file.getContents(), file.getCharset()), file.getName());
+						
+					} catch(ParseException ex){
+						Matcher matcher = PATTERN.matcher(ex.getMessage());
+						if(matcher.find()){
+							ValidationDocument doc = new ValidationDocument(file);
+							int line = Integer.parseInt(matcher.group(1));
+							int offset = doc.getOffsetByLine(line - 1);
+							int length = doc.getLineLength(line - 1);
+							
+							String text = ex.getMessage();
+							text = text.replaceAll("[ \t\r\n]+", " ");
+							
+							ValidatorUtils.createWarningMessage(this, reporter, file,
+									"velocityParseError", new String[]{text}, offset, length, line);
+						}
+					}
+				} catch(Exception ex){
+					ClickPlugin.log(ex);
+				}
+			}
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/ValidationDocument.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/ValidationDocument.java
new file mode 100644
index 0000000..3e67083
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/ValidationDocument.java
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.validator;
+
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+
+import org.eclipse.core.resources.IFile;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class ValidationDocument {
+	
+	private String[] lines;
+	
+	/**
+	 * The constructor.
+	 * 
+	 * @param file the <code>IFile</code> instance
+	 * @throws Exception
+	 */
+	public ValidationDocument(IFile file) throws Exception {
+		InputStream in = file.getContents();
+		ByteArrayOutputStream out = new ByteArrayOutputStream();
+		
+		int len = 0;
+		byte[] buf = new byte[1024 * 8];
+		while((len = in.read(buf))!=-1){
+			out.write(buf,0,len);
+		}
+		byte[] result = out.toByteArray();
+		in.close();
+		out.close();
+		
+		String source = new String(result, file.getCharset());
+		source = source.replaceAll("\r\n", " \n");
+		source = source.replaceAll("\r", "\n");
+		
+		this.lines = source.split("\n");
+	}
+	
+	/**
+	 * Returns the start offset of the specified line.
+	 * 
+	 * @param line the line number
+	 * @return the start offset of the specified line
+	 */
+	public int getOffsetByLine(int line){
+		int offset = 0;
+		for(int i=0;i<line;i++){
+			offset = offset + this.lines[i].length() + 1;
+		}
+		return offset;
+	}
+	
+	/**
+	 * Returns the length of the specified line.
+	 * 
+	 * @param line the line number
+	 * @return the length of the specified line 
+	 */
+	public int getLineLength(int line){
+		return this.lines[line].length();
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/ValidatorUtils.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/ValidatorUtils.java
new file mode 100644
index 0000000..cc39957
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/ValidatorUtils.java
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.core.validator;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.wst.validation.internal.core.Message;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+import org.eclipse.wst.validation.internal.provisional.core.IReporter;
+import org.eclipse.wst.validation.internal.provisional.core.IValidator;
+
+/**
+ * Provides utility methods for validation.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ValidatorUtils {
+	
+	/**
+	 * Creates the warning message.
+	 * 
+	 * @param validator the instance of IValidator
+	 * @param reporter the instanceof IReporter
+	 * @param file the instanceof IFile which will be marked
+	 * @param id the message id
+	 * @param params the message parameters
+	 * @param start ths start offset or -1
+	 * @param length the length or -1
+	 * @param line the line number or -1
+	 */
+	public static void createWarningMessage(IValidator validator, IReporter reporter, IFile file, 
+			String id, String[] params, int start, int length, int line){
+		
+		Message message = new Message();
+		message.setSeverity(IMessage.NORMAL_SEVERITY);
+		if(line>=0){
+			message.setLineNo(line);
+		}
+		if(start>=0){
+			message.setOffset(start);
+			message.setLength(length);
+		}
+		message.setBundleName("net.sf.clickide.core.validator.validation");
+		message.setId(id);
+		message.setParams(params);
+		message.setTargetObject(file);
+		reporter.addMessage(validator, message);
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/validation.properties b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/validation.properties
new file mode 100644
index 0000000..6edcb07
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/validation.properties
@@ -0,0 +1,25 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+notExist={0} does not exist.
+autoMapping=automapping must be true|false.
+autoBinding=autobinding must be true|false.
+headerType=type must be String|Integer|Date.
+modeValue=mode value must be production|profile|development|debug|trace.
+modeLogTo=logto must be console|servlet.
+unsupportedEncoding={0} is unsupported encoding.
+velocityParseError={0}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/validation_ja.properties b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/validation_ja.properties
new file mode 100644
index 0000000..3cb0295
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/core/validator/validation_ja.properties
@@ -0,0 +1,25 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+notExist={0} \u306f\u5b58\u5728\u3057\u307e\u305b\u3093\u3002
+autoMapping=automapping\u5c5e\u6027 \u306f true|false \u3067\u306a\u3051\u308c\u3070\u3044\u3051\u307e\u305b\u3093\u3002
+autoBinding=autobinding\u5c5e\u6027 \u306f true|false \u3067\u306a\u3051\u308c\u3070\u3044\u3051\u307e\u305b\u3093\u3002
+headerType=type\u5c5e\u6027 \u306f String|Integer|Date \u3067\u306a\u3051\u308c\u3070\u3044\u3051\u307e\u305b\u3093\u3002
+modeValue=value\u5c5e\u6027\u306f production|profile|development|debug|trace \u3067\u306a\u3051\u308c\u3070\u3044\u3051\u307e\u305b\u3093\u3002
+modeLogTo=logto\u5c5e\u6027\u306f console|servlet \u3067\u306a\u3051\u308c\u3070\u3044\u3051\u307e\u305b\u3093\u3002
+unsupportedEncoding={0} \u306f\u30b5\u30dd\u30fc\u30c8\u3055\u308c\u3066\u3044\u306a\u3044\u30a8\u30f3\u30b3\u30fc\u30c7\u30a3\u30f3\u30b0\u3067\u3059\u3002
+velocityParseError={0}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickPreferenceInitializer.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickPreferenceInitializer.java
new file mode 100644
index 0000000..c9ccccd
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickPreferenceInitializer.java
@@ -0,0 +1,64 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.preferences;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jface.resource.StringConverter;
+import org.eclipse.swt.graphics.RGB;
+
+/**
+ * Initializes the preference store.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickPreferenceInitializer extends AbstractPreferenceInitializer {
+
+	public void initializeDefaultPreferences() {
+		IPreferenceStore store = ClickPlugin.getDefault().getPreferenceStore();
+		try {
+			store.setDefault(ClickPlugin.PREF_TEMPLATES, getResourceAsText("default_templates.xml"));
+			store.setDefault(ClickPlugin.PREF_COLOR_VAR, StringConverter.asString(new RGB(128,0,0)));
+			store.setDefault(ClickPlugin.PREF_COLOR_DIR, StringConverter.asString(new RGB(0,0,128)));
+			store.setDefault(ClickPlugin.PREF_COLOR_CMT, StringConverter.asString(new RGB(0,128,0)));
+		} catch(Exception ex){
+			ClickPlugin.log(ex);
+		}
+	}
+	
+	private static String getResourceAsText(String resource) throws IOException {
+		InputStream in = null;
+		try {
+			in = ClickPreferenceInitializer.class.getResourceAsStream(resource);
+			byte[] buf = new byte[in.available()];
+			in.read(buf);
+			return new String(buf);
+		} finally {
+			if(in!=null){
+				in.close();
+			}
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickPreferencePage.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickPreferencePage.java
new file mode 100644
index 0000000..8d75368
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickPreferencePage.java
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.preferences;
+
+import org.eclipse.jface.preference.PreferencePage;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.IWorkbenchPreferencePage;
+
+/**
+ * An empty preference page.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickPreferencePage extends PreferencePage implements
+		IWorkbenchPreferencePage {
+
+	public ClickPreferencePage() {
+		super();
+	}
+
+	protected Control createContents(Composite parent) {
+		Composite composite = new Composite(parent, SWT.NULL);
+		composite.setLayout(new GridLayout(2, false));
+		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
+		return composite;
+	}
+
+	public void init(IWorkbench workbench) {
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickProjectPropertyPage.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickProjectPropertyPage.java
new file mode 100644
index 0000000..9c49ff0
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickProjectPropertyPage.java
@@ -0,0 +1,327 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.preferences;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.ProjectScope;
+import org.eclipse.core.runtime.IAdaptable;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.search.SearchEngine;
+import org.eclipse.jdt.ui.IJavaElementSearchConstants;
+import org.eclipse.jdt.ui.JavaUI;
+import org.eclipse.jface.dialogs.Dialog;
+import org.eclipse.jface.dialogs.ProgressMonitorDialog;
+import org.eclipse.jface.viewers.ArrayContentProvider;
+import org.eclipse.jface.viewers.ILabelProviderListener;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.ITableLabelProvider;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.TableViewer;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.TableColumn;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.dialogs.PropertyPage;
+import org.eclipse.ui.dialogs.SelectionDialog;
+import org.eclipse.ui.preferences.ScopedPreferenceStore;
+
+/**
+ * The project property page to define additonal Velocity variables.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickProjectPropertyPage extends PropertyPage {
+	
+	private List<VariableModel> models = new ArrayList<VariableModel>();
+	private TableViewer viewer;
+	
+	public ClickProjectPropertyPage(){
+		setTitle(ClickPlugin.getString("propertyPage.variables.title"));
+		setDescription(ClickPlugin.getString("propertyPage.variables.description"));
+	}
+	
+	protected Control createContents(Composite parent) {
+		Composite composite = new Composite(parent, SWT.NULL);
+		composite.setLayout(new GridLayout(2, false));
+		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
+		
+		viewer = new TableViewer(composite, 
+				SWT.FULL_SELECTION|SWT.V_SCROLL|SWT.H_SCROLL|SWT.BORDER);
+		Table table = viewer.getTable();
+		table.setLinesVisible(true);
+		table.setLayoutData(new GridData(GridData.FILL_BOTH));
+		table.setHeaderVisible(true);
+		
+		TableColumn column1 = new TableColumn(table, SWT.NULL);
+		column1.setText(ClickPlugin.getString("propertyPage.variables.column.name"));
+		column1.setWidth(80);
+		
+		TableColumn column2 = new TableColumn(table, SWT.NULL);
+		column2.setText(ClickPlugin.getString("propertyPage.variables.column.type"));
+		column2.setWidth(200);
+		
+		Composite buttons = new Composite(composite, SWT.NULL);
+		GridLayout layout = new GridLayout(1, false);
+		layout.marginHeight = 0;
+		layout.marginBottom = 0;
+		layout.marginLeft = 0;
+		layout.marginRight = 0;
+		buttons.setLayout(layout);
+		buttons.setLayoutData(new GridData(GridData.VERTICAL_ALIGN_BEGINNING));
+		
+		Button addButton = new Button(buttons, SWT.PUSH);
+		addButton.setText(ClickPlugin.getString("action.add"));
+		addButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		addButton.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent e) {
+				VariableModel model = new VariableModel();
+				VelocityVariableDialog dialog = new VelocityVariableDialog(viewer.getTable().getShell(), model);
+				if(dialog.open() == Dialog.OK){
+					models.add(model);
+					viewer.refresh();
+				}
+			}
+		});
+		
+		final Button editButton = new Button(buttons, SWT.PUSH);
+		editButton.setText(ClickPlugin.getString("action.edit"));
+		editButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		editButton.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent e) {
+				IStructuredSelection sel = (IStructuredSelection) viewer.getSelection();
+				if(!sel.isEmpty()){
+					VariableModel model = (VariableModel) sel.getFirstElement();
+					VelocityVariableDialog dialog = new VelocityVariableDialog(viewer.getTable().getShell(), model);
+					if(dialog.open() == Dialog.OK){
+						viewer.refresh();
+					}
+				}
+			}
+		});
+		editButton.setEnabled(false);
+		
+		final Button removeButton = new Button(buttons, SWT.PUSH);
+		removeButton.setText(ClickPlugin.getString("action.remove"));
+		removeButton.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		removeButton.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent e) {
+				IStructuredSelection sel = (IStructuredSelection) viewer.getSelection();
+				if(!sel.isEmpty()){
+					models.removeAll(sel.toList());
+					viewer.refresh();
+				}
+			}
+		});
+		removeButton.setEnabled(false);
+		
+		viewer.addSelectionChangedListener(new ISelectionChangedListener(){
+			public void selectionChanged(SelectionChangedEvent event) {
+				IStructuredSelection sel = (IStructuredSelection) viewer.getSelection();
+				editButton.setEnabled(!sel.isEmpty());
+				removeButton.setEnabled(!sel.isEmpty());
+			}
+		});
+		
+		viewer.setContentProvider(new ArrayContentProvider());
+		viewer.setLabelProvider(new ITableLabelProvider(){
+			public Image getColumnImage(Object row, int column) {
+				return null;
+			}
+			public String getColumnText(Object row, int column) {
+				if(column==0){
+					return ((VariableModel) row).name;
+				} else if(column==1){
+					return ((VariableModel) row).type;
+				}
+				return null;
+			}
+			public void addListener(ILabelProviderListener listener) {
+			}
+			public void dispose() {
+			}
+			public boolean isLabelProperty(Object row, String property) {
+				return false;
+			}
+			public void removeListener(ILabelProviderListener listener) {
+			}
+		});
+		
+		ScopedPreferenceStore store = new ScopedPreferenceStore(
+				new ProjectScope(getProject()), ClickPlugin.PLUGIN_ID);
+		String vars = store.getString(ClickPlugin.PREF_VELOCITY_VARS);
+		if(vars != null && vars.length() > 0){
+			models = VariableModel.deserialize(vars);
+		}
+		
+		viewer.setInput(models);
+		
+		return composite;
+	}
+	
+	private IProject getProject(){
+		IAdaptable adaptable = getElement();
+		if(adaptable instanceof IProject){
+			return (IProject) adaptable;
+		}
+		return (IProject) adaptable.getAdapter(IProject.class);
+	}
+	
+	protected void performDefaults() {
+		models.clear();
+		super.performDefaults();
+	}
+
+	public boolean performOk() {
+		ScopedPreferenceStore store = new ScopedPreferenceStore(
+				new ProjectScope(getProject()), ClickPlugin.PLUGIN_ID);
+		store.setValue(ClickPlugin.PREF_VELOCITY_VARS, VariableModel.serialize(models));
+		try {
+			store.save();
+		} catch(IOException ex){
+			ClickPlugin.log(ex);
+			return false;
+		}
+		return super.performOk();
+	}
+
+
+
+	/**
+	 * The dialog to register / modify a Velocity variable.
+	 */
+	private class VelocityVariableDialog extends Dialog {
+		
+		private Text name;
+		private Text type;
+		private VariableModel model;
+		
+		public VelocityVariableDialog(Shell parent, VariableModel model){
+			super(parent);
+			this.model = model;
+		}
+		
+//		protected Point getInitialSize() {
+//			Point point = super.getInitialSize();
+//			point.x = 350;
+//			return point;
+//		}
+
+		protected Control createDialogArea(Composite parent) {
+			getShell().setText(ClickPlugin.getString("propertyPage.variables.dialog.title"));
+			
+			Composite composite = new Composite(parent, SWT.NULL);
+			composite.setLayout(new GridLayout(3, false));
+			composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+			
+			new Label(composite, SWT.NULL).setText(ClickPlugin.getString("propertyPage.variables.dialog.name"));
+			name = new Text(composite, SWT.BORDER);
+			name.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+			name.setText(model.name);
+			new Label(composite, SWT.NULL);
+			
+			new Label(composite, SWT.NULL).setText(ClickPlugin.getString("propertyPage.variables.dialog.type"));
+			type = new Text(composite, SWT.BORDER);
+			type.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+			type.setText(model.type);
+			Button browseButton = new Button(composite, SWT.PUSH);
+			browseButton.setText(ClickPlugin.getString("action.browse"));
+			browseButton.addSelectionListener(new SelectionAdapter(){
+				public void widgetSelected(SelectionEvent evt){
+					Shell shell = type.getShell();
+					try {
+						SelectionDialog dialog = JavaUI.createTypeDialog(
+								shell,new ProgressMonitorDialog(shell),
+								SearchEngine.createJavaSearchScope(new IJavaElement[]{JavaCore.create(getProject())}),
+								IJavaElementSearchConstants.CONSIDER_CLASSES,false);
+						
+						if(dialog.open()==SelectionDialog.OK){
+							Object[] result = dialog.getResult();
+							type.setText(((IType)result[0]).getFullyQualifiedName());
+						}
+					} catch(Exception ex){
+						ClickPlugin.log(ex);
+					}
+				}
+			});
+			
+			
+			return composite;
+		}
+
+		protected void okPressed() {
+			model.name = name.getText();
+			model.type = type.getText();
+			super.okPressed();
+		}
+	}
+	
+	/**
+	 * The model of Velocity variables.
+	 */
+	public static class VariableModel {
+		public String name = "";
+		public String type = "";
+		
+		public static String serialize(List<VariableModel> models){
+			StringBuffer sb = new StringBuffer();
+			for(int i=0;i<models.size();i++){
+				VariableModel model = (VariableModel) models.get(i);
+				if(sb.length() != 0){
+					sb.append(",");
+				}
+				sb.append(model.name);
+				sb.append("=");
+				sb.append(model.type);
+			}
+			return sb.toString();
+		}
+		
+		public static List<VariableModel> deserialize(String value){
+			List<VariableModel> list = new ArrayList<VariableModel>();
+			String[] dim = value.split(",");
+			for(int i=0;i<dim.length;i++){
+				String[] nameAndType = dim[i].split("=");
+				VariableModel model = new VariableModel();
+				model.name = nameAndType[0];
+				model.type = nameAndType[1];
+				list.add(model);
+			}
+			return list;
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickTemplatePreferencePage.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickTemplatePreferencePage.java
new file mode 100644
index 0000000..392ea92
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/ClickTemplatePreferencePage.java
@@ -0,0 +1,325 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.preferences;
+
+import java.util.List;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.jface.dialogs.Dialog;
+import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jface.preference.PreferencePage;
+import org.eclipse.jface.viewers.ArrayContentProvider;
+import org.eclipse.jface.viewers.ILabelProviderListener;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.ITableLabelProvider;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.TableViewer;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.swt.widgets.TabFolder;
+import org.eclipse.swt.widgets.TabItem;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.TableColumn;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.IWorkbenchPreferencePage;
+
+/**
+ * The preference page to configure templates.
+ * These templates are used in the New Click Page Creation Wizard.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickTemplatePreferencePage extends PreferencePage implements
+		IWorkbenchPreferencePage {
+
+	private TableViewer tableViewer;
+	private List<Template> tableModel = Template.loadFromPreference();
+	
+	public ClickTemplatePreferencePage() {
+		super();
+		setPreferenceStore(ClickPlugin.getDefault().getPreferenceStore());
+	}
+
+	protected Control createContents(Composite parent) {
+		Composite composite = new Composite(parent, SWT.NULL);
+		composite.setLayout(new GridLayout(2, false));
+		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
+		
+		// Initializes TableViewer
+		tableViewer = new TableViewer(composite, 
+				SWT.V_SCROLL|SWT.H_SCROLL|SWT.BORDER|SWT.FULL_SELECTION);
+		
+		Table table = tableViewer.getTable();
+		table.setHeaderVisible(true);
+		table.setLinesVisible(true);
+		table.setLayoutData(new GridData(GridData.FILL_BOTH));
+		
+		TableColumn column1 = new TableColumn(table, SWT.LEFT);
+		column1.setText(ClickPlugin.getString("preferences.template.name"));
+		column1.setWidth(80);
+		
+		TableColumn column2 = new TableColumn(table, SWT.LEFT);
+		column2.setText(ClickPlugin.getString("preferences.template.pageClass"));
+		column2.setWidth(100);
+		
+		TableColumn column3 = new TableColumn(table, SWT.LEFT);
+		column3.setText(ClickPlugin.getString("preferences.template.htmlTemplate"));
+		column3.setWidth(100);
+		
+		tableViewer.setContentProvider(new ArrayContentProvider());
+		tableViewer.setLabelProvider(new ITableLabelProvider(){
+			public Image getColumnImage(Object element, int columnIndex) {
+				return null;
+			}
+			public String getColumnText(Object element, int columnIndex) {
+				Template template = (Template)element;
+				switch(columnIndex){
+				case 0: return template.getName();
+				case 1: return template.getPageClass();
+				case 2: return template.getHtmlTemplate();
+				}
+				return null;
+			}
+			public void addListener(ILabelProviderListener listener) {
+			}
+			public void dispose() {
+			}
+			public boolean isLabelProperty(Object element, String property) {
+				return false;
+			}
+			public void removeListener(ILabelProviderListener listener) {
+			}
+		});
+		tableViewer.setInput(tableModel);
+		
+		// Initializes Buttons
+		Composite buttons = new Composite(composite, SWT.NULL);
+		buttons.setLayout(new GridLayout(1, false));
+		GridData gd = new GridData(GridData.VERTICAL_ALIGN_BEGINNING);
+		gd.widthHint = 80;
+		buttons.setLayoutData(gd);
+		
+		Button add = new Button(buttons, SWT.PUSH);
+		add.setText(ClickPlugin.getString("action.add"));
+		add.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		add.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				TemplateDialog dialog = new TemplateDialog(getShell());
+				if(dialog.open()==Dialog.OK){
+					tableModel.add(dialog.getTemplate());
+					tableViewer.refresh();
+				}
+			}
+		});
+		
+		final Button edit = new Button(buttons, SWT.PUSH);
+		edit.setText(ClickPlugin.getString("action.edit"));
+		edit.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		edit.setEnabled(false);
+		edit.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				IStructuredSelection selection = (IStructuredSelection)tableViewer.getSelection();
+				Template template = (Template)selection.getFirstElement();
+				TemplateDialog dialog = new TemplateDialog(getShell(), template);
+				if(dialog.open()==Dialog.OK){
+					tableViewer.refresh();
+				}
+			}
+		});
+		
+		final Button remove = new Button(buttons, SWT.PUSH);
+		remove.setText(ClickPlugin.getString("action.remove"));
+		remove.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		remove.setEnabled(false);
+		remove.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				IStructuredSelection selection = (IStructuredSelection)tableViewer.getSelection();
+				tableModel.removeAll(selection.toList());
+				tableViewer.refresh();
+			}
+		});
+		
+		tableViewer.addSelectionChangedListener(new ISelectionChangedListener(){
+			public void selectionChanged(SelectionChangedEvent event){
+				if(tableViewer.getTable().getSelectionCount()==0){
+					edit.setEnabled(false);
+					remove.setEnabled(false);
+				} else {
+					edit.setEnabled(true);
+					remove.setEnabled(true);
+				}
+			}
+		});
+		
+		return composite;
+	}
+
+	public void init(IWorkbench workbench) {
+	}
+	
+	public boolean performOk() {
+		Template.saveToPreference(tableModel);
+		return super.performOk();
+	}
+	
+	protected void performDefaults() {
+		String xml = getPreferenceStore().getDefaultString(ClickPlugin.PREF_TEMPLATES);
+		
+		tableModel.clear();
+		tableModel.addAll(Template.loadFromXML(xml));
+		tableViewer.refresh();
+		
+		super.performDefaults();
+	}
+	
+	/**
+	 * The dialog to create/edit templates.
+	 */
+	private class TemplateDialog extends Dialog {
+
+		private Text name;
+		private Text pageClass;
+		private Text htmlTemplate;
+		private Template template;
+		
+		public TemplateDialog(Shell parentShell) {
+			this(parentShell, null);
+		}
+
+		public TemplateDialog(Shell parentShell, Template template) {
+			super(parentShell);
+			setShellStyle(getShellStyle()|SWT.RESIZE);
+			this.template = template;
+		}
+		
+		protected Point getInitialSize() {
+			return new Point(400,350);
+		}
+		
+		protected void createButtonsForButtonBar(Composite parent) {
+			super.createButtonsForButtonBar(parent);
+			updateButtonStatus();
+		}
+		
+		protected Control createDialogArea(Composite parent) {
+			getShell().setText(ClickPlugin.getString("preferences.template"));
+			
+			Composite composite = new Composite(parent, SWT.NULL);
+			composite.setLayout(new GridLayout(2, false));
+			composite.setLayoutData(new GridData(GridData.FILL_BOTH));
+			
+			ClickUtils.createLabel(composite, 
+					ClickPlugin.getString("preferences.template.name")+":");
+			name = new Text(composite, SWT.BORDER);
+			name.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+			if(template!=null){
+				name.setText(template.getName());
+			}
+			name.addModifyListener(new ModifyListener(){
+				public void modifyText(ModifyEvent e){
+					updateButtonStatus();
+				}
+			});
+			
+			TabFolder tabFolder = new TabFolder(composite,SWT.NULL);
+			tabFolder.setLayoutData(ClickUtils.createGridData(2, GridData.FILL_BOTH));
+			
+			// Page Class Tab
+			TabItem item1 = new TabItem(tabFolder,SWT.NULL);
+			item1.setText(ClickPlugin.getString("preferences.template.pageClass"));
+			Composite composite1 = new Composite(tabFolder, SWT.NULL);
+			composite1.setLayout(createPanelLayout());
+			
+			pageClass = new Text(composite1, SWT.BORDER|SWT.MULTI|SWT.V_SCROLL);
+			pageClass.setLayoutData(new GridData(GridData.FILL_BOTH));
+			if(template!=null){
+				pageClass.setText(template.getPageClass());
+			}
+			ClickUtils.createLabel(composite1, 
+					ClickPlugin.getString("preferences.template.dialog.variables"));
+			ClickUtils.createLabel(composite1, 
+					"${package}, ${classname}, ${superclass}");
+			item1.setControl(composite1);
+			
+			// HTML Template Tab
+			TabItem item2 = new TabItem(tabFolder,SWT.NULL);
+			item2.setText(ClickPlugin.getString("preferences.template.htmlTemplate"));
+			Composite composite2 = new Composite(tabFolder, SWT.NULL);
+			composite2.setLayout(createPanelLayout());
+			
+			htmlTemplate = new Text(composite2, SWT.BORDER|SWT.MULTI|SWT.V_SCROLL);
+			htmlTemplate.setLayoutData(new GridData(GridData.FILL_BOTH));
+			if(template!=null){
+				htmlTemplate.setText(template.getHtmlTemplate());
+			}
+			ClickUtils.createLabel(composite2, 
+					ClickPlugin.getString("preferences.template.dialog.variables"));
+			ClickUtils.createLabel(composite2, "${charset}");
+			item2.setControl(composite2);
+			
+			return composite;
+		}
+		
+		private GridLayout createPanelLayout(){
+			GridLayout layout = new GridLayout(1, false);
+			layout.marginTop = 0;
+			layout.marginBottom = 0;
+			layout.marginLeft = 0;
+			layout.marginRight = 0;
+			layout.marginWidth = 0;
+			layout.marginHeight = 0;
+			return layout;
+		}
+		
+		private void updateButtonStatus(){
+			getButton(IDialogConstants.OK_ID).setEnabled(name.getText().length()>0);
+		}
+		
+		protected void okPressed() {
+			if(template==null){
+				template = new Template();
+			}
+			template.setName(name.getText());
+			template.setPageClass(pageClass.getText());
+			template.setHtmlTemplate(htmlTemplate.getText());
+			
+			super.okPressed();
+		}
+		
+		public Template getTemplate(){
+			return template;
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/Template.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/Template.java
new file mode 100644
index 0000000..0477352
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/Template.java
@@ -0,0 +1,164 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.preferences;
+
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.List;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.xerces.parsers.DOMParser;
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.Text;
+import org.xml.sax.InputSource;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class Template {
+	
+	private String name;
+	private String pageClass;
+	private String htmlTemplate;
+	
+	/**
+	 * Returns the HTML template.
+	 * @return the HTML template
+	 */
+	public String getHtmlTemplate() {
+		return htmlTemplate;
+	}
+	
+	/**
+	 * Sets the HTML template.
+	 * @param htmlTemplate the HTML template
+	 */
+	public void setHtmlTemplate(String htmlTemplate) {
+		this.htmlTemplate = htmlTemplate;
+	}
+	
+	/**
+	 * Returns the template name.
+	 * @return the template name
+	 */
+	public String getName() {
+		return name;
+	}
+	
+	/**
+	 * Sets the template name.
+	 * @param name the template name
+	 */
+	public void setName(String name) {
+		this.name = name;
+	}
+	
+	/**
+	 * Returns the page class template.
+	 * @return the page class template
+	 */
+	public String getPageClass() {
+		return pageClass;
+	}
+	
+	/**
+	 * Sets the page class tenmplate.
+	 * @param pageClass the page class template
+	 */
+	public void setPageClass(String pageClass) {
+		this.pageClass = pageClass;
+	}
+	
+	public String toXML(){
+		StringBuffer sb = new StringBuffer();
+		sb.append("<template name=\"").append(ClickUtils.escapeXML(name)).append("\">");
+		sb.append("<class>").append(ClickUtils.escapeXML(pageClass)).append("</class>");
+		sb.append("<html>").append(ClickUtils.escapeXML(htmlTemplate)).append("</html>");
+		sb.append("</template>");
+		return sb.toString();
+	}
+	
+	public static List<Template> loadFromXML(String xml){
+		List<Template> list = new ArrayList<Template>();
+		try {
+			DOMParser parser = new DOMParser();
+			parser.parse(new InputSource(new StringReader(xml)));
+			Document doc = parser.getDocument();
+			Element element = doc.getDocumentElement();
+			NodeList templates = element.getElementsByTagName("template");
+			for(int i=0;i<templates.getLength();i++){
+				Element template = (Element)templates.item(i);
+				String name = template.getAttribute("name");
+				
+				Element clazz = (Element)template.getElementsByTagName("class").item(0);
+				String classTemplate = getChildText(clazz).trim();
+				
+				Element html = (Element)template.getElementsByTagName("html").item(0);
+				String htmlTemplate = getChildText(html).trim();
+				
+				Template tmpl = new Template();
+				tmpl.setName(name);
+				tmpl.setPageClass(classTemplate);
+				tmpl.setHtmlTemplate(htmlTemplate);
+				list.add(tmpl);
+			}
+		} catch(Exception ex){
+			ClickPlugin.log(ex);
+		}
+		return list;
+	}
+	
+	
+	public static List<Template> loadFromPreference(){
+		IPreferenceStore store = ClickPlugin.getDefault().getPreferenceStore();
+		String xml = store.getString(ClickPlugin.PREF_TEMPLATES);
+		return loadFromXML(xml);
+	}
+	
+	private static String getChildText(Element element){
+		StringBuffer sb = new StringBuffer();
+		NodeList children = element.getChildNodes();
+		for(int i=0;i<children.getLength();i++){
+			Node node = children.item(i);
+			if(node instanceof Text){
+				sb.append(((Text)node).getNodeValue());
+			}
+		}
+		return sb.toString();
+	}
+	
+	public static void saveToPreference(List<Template> templates){
+		StringBuffer sb = new StringBuffer();
+		sb.append("<templates>");
+		for(int i=0;i<templates.size();i++){
+			sb.append(((Template)templates.get(i)).toXML());
+		}
+		sb.append("</templates>");
+		
+		IPreferenceStore store = ClickPlugin.getDefault().getPreferenceStore();
+		store.setValue(ClickPlugin.PREF_TEMPLATES, sb.toString());
+	}
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/TemplateEditorPreferencePage.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/TemplateEditorPreferencePage.java
new file mode 100644
index 0000000..2a3281b
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/TemplateEditorPreferencePage.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.preferences;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.eclipse.jface.preference.ColorFieldEditor;
+import org.eclipse.jface.preference.FieldEditorPreferencePage;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.IWorkbenchPreferencePage;
+
+public class TemplateEditorPreferencePage extends FieldEditorPreferencePage implements IWorkbenchPreferencePage {
+	
+	public TemplateEditorPreferencePage(){
+		super(GRID);
+		setPreferenceStore(ClickPlugin.getDefault().getPreferenceStore());
+	}
+	
+	protected void createFieldEditors() {
+		setTitle(ClickPlugin.getString("preferences.templateEditor"));
+		Composite parent = getFieldEditorParent();
+		
+		ColorFieldEditor variable = new ColorFieldEditor(
+				ClickPlugin.PREF_COLOR_VAR, 
+				ClickPlugin.getString("preferences.templateEditor.colorVariable"), parent);
+		addField(variable);
+		
+		ColorFieldEditor directive = new ColorFieldEditor(
+				ClickPlugin.PREF_COLOR_DIR,
+				ClickPlugin.getString("preferences.templateEditor.colorDirective"), parent);
+		addField(directive);
+		
+		ColorFieldEditor comment = new ColorFieldEditor(
+				ClickPlugin.PREF_COLOR_CMT, 
+				ClickPlugin.getString("preferences.templateEditor.colorComment"), parent);
+		addField(comment);
+	}
+
+	public void init(IWorkbench workbench) {
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/default_templates.xml b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/default_templates.xml
new file mode 100644
index 0000000..c04f7b5
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/preferences/default_templates.xml
@@ -0,0 +1,82 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<templates>
+	<template name="Blank">
+		<class>
+<![CDATA[
+package ${package};
+
+public class ${classname} extends ${superclass} {
+	
+	public ${classname}(){
+	}
+
+}
+]]>
+		</class>
+		<html>
+<![CDATA[
+<html>
+  <head>
+    <META HTTP-EQUIV="Content-Type" CONTENT="text/html;charset=${charset}">
+    <title>Blank</title>
+    $imports
+  </head>
+  <body>
+  </body>
+</html>
+]]>
+		</html>
+	</template>
+	<template name="Simple Form">
+		<class>
+<![CDATA[
+package ${package};
+
+import org.apache.click.control.Form;
+
+public class ${classname} extends ${superclass} {
+
+	private static final long serialVersionUID = 1L;
+	
+	private Form form = new Form("form");
+	
+	public ${classname}(){
+		addControl(form);
+	}
+
+}
+]]>
+		</class>
+		<html>
+<![CDATA[
+<html>
+  <head>
+    <META HTTP-EQUIV="Content-Type" CONTENT="text/html;charset=${charset}">
+    <title>Simple Form</title>
+    $imports
+  </head>
+  <body>
+    $form
+  </body>
+</html>
+]]>
+		</html>
+	</template>
+</templates>
\ No newline at end of file
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/NewClickPageAction.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/NewClickPageAction.java
new file mode 100644
index 0000000..5b4ba21
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/NewClickPageAction.java
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.actions;
+
+
+import org.apache.click.eclipse.ui.wizard.NewClickPageWizard;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.wizard.WizardDialog;
+import org.eclipse.ui.IWorkbenchWindow;
+import org.eclipse.ui.IWorkbenchWindowActionDelegate;
+import org.eclipse.ui.PlatformUI;
+
+/**
+ * Opens the New Click Page wizard.
+ * 
+ * @author Naoki Takezoe
+ * @see NewClickPageWizard
+ */
+public class NewClickPageAction implements IWorkbenchWindowActionDelegate {
+	
+	private IWorkbenchWindow window;
+	private IStructuredSelection selection;
+	
+	public void selectionChanged(IAction action, ISelection selection) {
+		if(selection instanceof IStructuredSelection){
+			this.selection = (IStructuredSelection)selection;
+		} else {
+			this.selection = null;
+		}
+	}
+
+	/**
+	 * Opens {@link org.apache.click.eclipse.ui.wizard.NewClickPageWizard}.
+	 */
+	public void run(IAction action) {
+		NewClickPageWizard wizard = new NewClickPageWizard();
+		wizard.init(PlatformUI.getWorkbench(), this.selection);
+		WizardDialog dialog = new WizardDialog(window.getShell(), wizard);
+		dialog.open();
+	}
+
+	public void dispose() {
+	}
+
+	public void init(IWorkbenchWindow window) {
+		this.window = window;
+	}
+}
\ No newline at end of file
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/SwitchToClassAction.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/SwitchToClassAction.java
new file mode 100644
index 0000000..cc64a64
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/SwitchToClassAction.java
@@ -0,0 +1,80 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.actions;
+
+import java.text.MessageFormat;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.ui.JavaUI;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.ui.IEditorActionDelegate;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IFileEditorInput;
+
+/**
+ * Switches to the page class from the HTML file.
+ * 
+ * @author Naoki Takezoe
+ * @see ClickUtils#getPageClassFromTemplate(IFile)
+ */
+public class SwitchToClassAction implements IEditorActionDelegate {
+	
+	private IEditorPart editor;
+	
+	public void selectionChanged(IAction action, ISelection selection) {
+		// Nothing to do
+	}
+	
+	public void setActiveEditor(IAction action, IEditorPart targetEditor) {
+		this.editor = targetEditor;
+	}
+
+	public void run(IAction action) {
+		IEditorInput input = this.editor.getEditorInput();
+		if(input instanceof IFileEditorInput){
+			IFile file = ((IFileEditorInput)input).getFile();
+			
+			if(!ClickUtils.isClickProject(file.getProject())){
+				ClickUtils.openErrorDialog(MessageFormat.format(
+					ClickPlugin.getString("wizard.newPage.error.notClickProject"), 
+					new Object[]{ file.getProject().getName() }));
+				return;
+			}
+			
+			try {
+				IType type = ClickUtils.getPageClassFromTemplate(file);
+				if(type!=null){
+					JavaUI.openInEditor(type);
+					return;
+				}
+			} catch(Exception ex){
+				ClickPlugin.log(ex);
+			}
+			ClickUtils.openErrorDialog(
+					ClickPlugin.getString("message.error.noPage"));
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/SwitchToHTMLAction.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/SwitchToHTMLAction.java
new file mode 100644
index 0000000..37787cf
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/SwitchToHTMLAction.java
@@ -0,0 +1,87 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.actions;
+
+import java.text.MessageFormat;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.internal.ui.JavaPlugin;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.ui.IEditorActionDelegate;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.IFileEditorInput;
+import org.eclipse.ui.ide.IDE;
+
+/**
+ * Switches to the HTML file from the page class.
+ * 
+ * @author Naoki Takezoe
+ * @see ClickUtils#getTemplateFromPageClass(IType)
+ */
+public class SwitchToHTMLAction implements IEditorActionDelegate {
+	
+	private IEditorPart editor;
+	
+	public void selectionChanged(IAction action, ISelection selection) {
+		// Nothing to do
+	}
+	
+	public void setActiveEditor(IAction action, IEditorPart targetEditor) {
+		this.editor = targetEditor;
+	}
+
+	public void run(IAction action) {
+		IEditorInput input = this.editor.getEditorInput();
+		if(input instanceof IFileEditorInput){
+			IFile file = ((IFileEditorInput)input).getFile();
+			
+			if(!ClickUtils.isClickProject(file.getProject())){
+				ClickUtils.openErrorDialog(MessageFormat.format(
+					ClickPlugin.getString("wizard.newPage.error.notClickProject"), 
+					new Object[]{ file.getProject().getName() }));
+				return;
+			}
+			
+			IJavaElement element = 
+				JavaPlugin.getDefault().getWorkingCopyManager().getWorkingCopy(input);
+			ICompilationUnit unit = (ICompilationUnit)element;
+			try {
+				IType type = unit.getAllTypes()[0];
+				IFile resource = ClickUtils.getTemplateFromPageClass(type);
+				if(resource!=null){
+					IDE.openEditor(ClickUtils.getActivePage(), (IFile)resource);
+					return;
+				}
+			} catch(Exception ex){
+				ClickPlugin.log(ex);
+			}
+			ClickUtils.openErrorDialog(
+					ClickPlugin.getString("message.error.noHtml"));
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/ToggleCommentAction.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/ToggleCommentAction.java
new file mode 100644
index 0000000..42e578e
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/actions/ToggleCommentAction.java
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.actions;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.eclipse.jface.action.Action;
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.ITextSelection;
+import org.eclipse.swt.SWT;
+import org.eclipse.ui.texteditor.ITextEditor;
+
+/**
+ *
+ * @author Naoki Takezoe
+ */
+public class ToggleCommentAction extends Action {
+
+	private ITextEditor editor;
+
+	public ToggleCommentAction(ITextEditor editor) {
+		super(ClickPlugin.getString("action.toggleComment"));
+		this.editor = editor;
+		setId(ToggleCommentAction.class.getName());
+		setActionDefinitionId(ToggleCommentAction.class.getName());
+		setAccelerator(SWT.CTRL | '/');
+	}
+
+	public void run() {
+		ITextSelection sel = (ITextSelection) editor.getSelectionProvider().getSelection();
+		IDocument doc = editor.getDocumentProvider().getDocument(editor.getEditorInput());
+
+		try {
+			int offset = doc.getLineOffset(sel.getStartLine());
+			String text = doc.get(offset, sel.getLength() + (sel.getOffset() - offset));
+
+			if(text.startsWith("##")){
+				text = text.replaceAll("(^|\r\n|\r|\n)##", "$1");
+			} else {
+				text = "##" + text.replaceAll("(\r\n|\r|\n)", "$1##");
+				if(text.endsWith("##")){
+					text = text.substring(0, text.length() - 2);
+				}
+			}
+
+			doc.replace(offset, sel.getLength() + (sel.getOffset() - offset), text);
+
+		} catch (BadLocationException e) {
+			e.printStackTrace();
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickActionBarContributor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickActionBarContributor.java
new file mode 100644
index 0000000..b1da2fd
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickActionBarContributor.java
@@ -0,0 +1,110 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor;
+
+import org.eclipse.ui.IActionBars;
+import org.eclipse.ui.IEditorActionBarContributor;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.part.MultiPageEditorActionBarContributor;
+import org.eclipse.wst.sse.ui.StructuredTextEditor;
+import org.eclipse.wst.sse.ui.internal.ISourceViewerActionBarContributor;
+import org.eclipse.wst.xml.ui.internal.tabletree.SourcePageActionContributor;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickActionBarContributor extends MultiPageEditorActionBarContributor {
+	
+	private IEditorActionBarContributor sourceViewerActionContributor = null;
+	private ClickEditor clickEditor = null;
+	
+	public ClickActionBarContributor(){
+		super();
+		sourceViewerActionContributor = new SourcePageActionContributor();
+	}
+	
+	public void init(IActionBars actionBars) {
+		super.init(actionBars);
+		if (actionBars != null) {
+			initSourceViewerActionContributor(actionBars);
+		}
+	}
+	
+	private void initSourceViewerActionContributor(IActionBars actionBars) {
+		if (sourceViewerActionContributor != null){
+			sourceViewerActionContributor.init(actionBars, getPage());
+		}
+	}
+	
+	public void dispose() {
+		super.dispose();
+
+		if (sourceViewerActionContributor != null){
+			sourceViewerActionContributor.dispose();
+		}
+	}
+	
+	public void setActiveEditor(IEditorPart targetEditor) {
+		if (targetEditor instanceof ClickEditor){
+			clickEditor = (ClickEditor) targetEditor;
+		}
+		super.setActiveEditor(targetEditor);
+	}
+	
+	public void setActivePage(IEditorPart activeEditor) {
+		// This contributor is designed for StructuredTextMultiPageEditorPart.
+		// To safe-guard this from problems caused by unexpected usage by
+		// other editors, the following
+		// check is added.
+		if (clickEditor != null) {
+			if (activeEditor != null && activeEditor instanceof StructuredTextEditor){
+				activateSourcePage(activeEditor);
+			} else {
+				activateDesignPage(activeEditor);
+			}
+		}
+		IActionBars actionBars = getActionBars();
+		if (actionBars != null) {
+			// update menu bar and tool bar
+			actionBars.updateActionBars();
+		}
+	}
+	
+	private void activateDesignPage(IEditorPart activeEditor) {
+		if (sourceViewerActionContributor != null && sourceViewerActionContributor instanceof ISourceViewerActionBarContributor) {
+			// if design page is not really an IEditorPart, activeEditor ==
+			// null, so pass in multiPageEditor instead (d282414)
+			if (activeEditor == null) {
+				sourceViewerActionContributor.setActiveEditor(clickEditor);
+			} else {
+				sourceViewerActionContributor.setActiveEditor(activeEditor);
+			}
+			((ISourceViewerActionBarContributor) sourceViewerActionContributor).setViewerSpecificContributionsEnabled(false);
+		}
+	}
+
+	private void activateSourcePage(IEditorPart activeEditor) {
+		if (sourceViewerActionContributor != null && sourceViewerActionContributor instanceof ISourceViewerActionBarContributor) {
+			sourceViewerActionContributor.setActiveEditor(activeEditor);
+			((ISourceViewerActionBarContributor) sourceViewerActionContributor).setViewerSpecificContributionsEnabled(true);
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickEditor.java
new file mode 100644
index 0000000..d349bab
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickEditor.java
@@ -0,0 +1,258 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ui.editor.forms.ClickControlsEditor;
+import org.apache.click.eclipse.ui.editor.forms.ClickGeneralEditor;
+import org.apache.click.eclipse.ui.editor.forms.ClickHeadersEditor;
+import org.apache.click.eclipse.ui.editor.forms.ClickPagesEditor;
+import org.apache.click.eclipse.ui.editor.forms.ClickServiceEditor;
+import org.eclipse.core.resources.IResourceChangeEvent;
+import org.eclipse.core.resources.IResourceChangeListener;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IEditorSite;
+import org.eclipse.ui.IFileEditorInput;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.ide.IGotoMarker;
+import org.eclipse.ui.part.FileEditorInput;
+import org.eclipse.ui.part.MultiPageEditorPart;
+import org.eclipse.ui.views.contentoutline.IContentOutlinePage;
+import org.eclipse.wst.sse.core.internal.provisional.IModelStateListener;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+import org.eclipse.wst.sse.ui.StructuredTextEditor;
+
+/**
+ * The editor for click.xml.
+ * <p>
+ * This editor provides the tree editor and the source editor
+ * as the multi-page editor. They can be toggled using tabs.
+ * </p>
+ *
+ * @author Naoki Takezoe
+ */
+public class ClickEditor extends MultiPageEditorPart implements IResourceChangeListener {
+
+	private StructuredTextEditor sourceEditor;
+	private ClickGeneralEditor generalEditor;
+	private ClickHeadersEditor headerEditor;
+	private ClickPagesEditor pageEditor;
+	private ClickControlsEditor controlEditor;
+	private ClickServiceEditor serviceEditor;
+
+//	private int generalEditorIndex;
+//	private int headerEditorIndex;
+//	private int pageEditorIndex;
+//	private int controlEditorIndex;
+	private int sourceEditorIndex = 0;
+
+	private IModelStateListener listener = new IModelStateListener(){
+		public void modelAboutToBeChanged(IStructuredModel model) {
+			modelUpdated(model);
+		}
+		public void modelAboutToBeReinitialized(IStructuredModel structuredModel) {
+			modelUpdated(structuredModel);
+		}
+		public void modelChanged(IStructuredModel model) {
+			modelUpdated(model);
+		}
+		public void modelDirtyStateChanged(IStructuredModel model, boolean isDirty) {
+			modelUpdated(model);
+		}
+		public void modelReinitialized(IStructuredModel structuredModel) {
+			modelUpdated(structuredModel);
+		}
+		public void modelResourceDeleted(IStructuredModel model) {
+			modelUpdated(model);
+		}
+		public void modelResourceMoved(IStructuredModel oldModel, IStructuredModel newModel) {
+			modelUpdated(newModel);
+		}
+	};
+
+	public ClickEditor() {
+		super();
+		ResourcesPlugin.getWorkspace().addResourceChangeListener(this);
+	}
+
+	public void createPages() {
+		try {
+			sourceEditor = new StructuredTextEditor();
+			addPage(0, sourceEditor, getEditorInput());
+			setPageText(0, ClickPlugin.getString("editor.clickXML.source"));
+		} catch(Exception ex){
+			ClickPlugin.log(ex);
+		}
+
+		IStructuredModel model = (IStructuredModel)sourceEditor.getAdapter(IStructuredModel.class);
+
+		try {
+			serviceEditor = new ClickServiceEditor();
+			addPage(0, serviceEditor, getEditorInput());
+			serviceEditor.initModel(model);
+			setPageText(0, ClickPlugin.getString("editor.clickXML.service"));
+			sourceEditorIndex++;
+		} catch(Exception ex){
+			removePage(0);
+		}
+		try {
+			controlEditor = new ClickControlsEditor();
+			addPage(0, controlEditor, getEditorInput());
+			controlEditor.initModel(model);
+			setPageText(0, ClickPlugin.getString("editor.clickXML.controls"));
+			sourceEditorIndex++;
+		} catch(Exception ex){
+			removePage(0);
+		}
+		try {
+			pageEditor = new ClickPagesEditor();
+			addPage(0, pageEditor, getEditorInput());
+			pageEditor.initModel(model);
+			setPageText(0, ClickPlugin.getString("editor.clickXML.pages"));
+			sourceEditorIndex++;
+		} catch(Exception ex){
+			removePage(0);
+		}
+		try {
+			headerEditor = new ClickHeadersEditor();
+			addPage(0, headerEditor, getEditorInput());
+			headerEditor.initModel(model);
+			setPageText(0, ClickPlugin.getString("editor.clickXML.headers"));
+			sourceEditorIndex++;
+		} catch(Exception ex){
+			removePage(0);
+		}
+		try {
+			generalEditor = new ClickGeneralEditor();
+			addPage(0, generalEditor, getEditorInput());
+			generalEditor.initModel(model);
+			setPageText(0, ClickPlugin.getString("editor.clickXML.general"));
+			sourceEditorIndex++;
+		} catch(Exception ex){
+			removePage(0);
+		}
+
+		model.addModelStateListener(listener);
+
+//		IContentOutlinePage outline
+//			= (IContentOutlinePage)sourceEditor.getAdapter(IContentOutlinePage.class);
+//		outline.addSelectionChangedListener(new ISelectionChangedListener(){
+//			public void selectionChanged(SelectionChangedEvent event){
+//				setActivePage(4);
+//			}
+//		});
+//		ConfigurableContentOutlinePage page = (ConfigurableContentOutlinePage)outline;
+//		System.out.println(page.getControl());
+
+		setActivePage(0);
+	}
+
+	@SuppressWarnings("unchecked")
+	public Object getAdapter(Class key) {
+		if (key.equals(IContentOutlinePage.class)) {
+			return sourceEditor.getAdapter(IContentOutlinePage.class);
+		} else if (key.equals(IGotoMarker.class)) {
+			setActivePage(sourceEditorIndex);
+			return sourceEditor.getAdapter(IGotoMarker.class);
+		} else {
+			return super.getAdapter(key);
+		}
+	}
+
+	public void doSave(IProgressMonitor progressMonitor) {
+		sourceEditor.doSave(progressMonitor);
+	}
+
+
+	public void doSaveAs() {
+		sourceEditor.doSaveAs();
+	}
+
+	public boolean isSaveAsAllowed() {
+		return true;
+	}
+
+	public void init(IEditorSite site, IEditorInput editorInput) throws PartInitException {
+		if (!(editorInput instanceof IFileEditorInput)){
+			throw new PartInitException("Unsupported editor input.");
+		}
+		super.init(site, editorInput);
+		setPartName(editorInput.getName());
+	}
+
+	public void setFocus() {
+		getControl(getActivePage()).setFocus();
+	}
+
+	public void dispose() {
+		ResourcesPlugin.getWorkspace().removeResourceChangeListener(this);
+		IStructuredModel model = (IStructuredModel)sourceEditor.getAdapter(IStructuredModel.class);
+		model.removeModelStateListener(listener);
+		super.dispose();
+	}
+
+	public void resourceChanged(final IResourceChangeEvent event){
+		Display.getDefault().asyncExec(new Runnable(){
+			public void run(){
+				if(!((FileEditorInput)sourceEditor.getEditorInput()).getFile().exists()){
+					IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
+					page.closeEditor(ClickEditor.this, false);
+				}
+			}
+		});
+	}
+
+	private void modelUpdated(IStructuredModel model){
+		if(getActivePage()==4){
+			generalEditor.modelUpdated(model);
+			controlEditor.modelUpdated(model);
+			headerEditor.modelUpdated(model);
+			pageEditor.modelUpdated(model);
+		}
+	}
+
+//	protected IEditorSite createSite(IEditorPart editor) {
+//		if(editor instanceof StructuredTextEditor){
+//			return new SourceEditorSite(this, editor, getEditorSite());
+//		} else {
+//			return super.createSite(editor);
+//		}
+//	}
+//
+//	private class SourceEditorSite extends MultiPageEditorSite {
+//
+//		private IEditorSite site;
+//
+//		public SourceEditorSite(MultiPageEditorPart multiPageEditor,IEditorPart editor,IEditorSite site) {
+//			super(multiPageEditor, editor);
+//			this.site = site;
+//		}
+//
+//		public IEditorActionBarContributor getActionBarContributor() {
+//			return site.getActionBarContributor();
+//		}
+//	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickXMLHyperlinkDetector.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickXMLHyperlinkDetector.java
new file mode 100644
index 0000000..2376a56
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickXMLHyperlinkDetector.java
@@ -0,0 +1,258 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.ui.JavaUI;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.jface.text.ITextViewer;
+import org.eclipse.jface.text.Region;
+import org.eclipse.jface.text.hyperlink.IHyperlink;
+import org.eclipse.jface.text.hyperlink.IHyperlinkDetector;
+import org.eclipse.ui.ide.IDE;
+import org.eclipse.wst.sse.core.StructuredModelManager;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
+import org.eclipse.wst.sse.core.utils.StringUtils;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMAttr;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
+import org.w3c.dom.Attr;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+/**
+ * The <code>IHyperlinkDetector</code> implementation 
+ * which provides hyperlink for classes and page path.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickXMLHyperlinkDetector implements IHyperlinkDetector {
+
+	public IHyperlink[] detectHyperlinks(ITextViewer textViewer, IRegion region, boolean canShowMultipleHyperlinks) {
+		if (region == null || textViewer == null) {
+			return null;
+		}
+
+		IDocument document = textViewer.getDocument();
+		Node currentNode = getCurrentNode(document, region.getOffset());
+		if (currentNode != null) {
+			short nodeType = currentNode.getNodeType();
+			if (nodeType == Node.DOCUMENT_TYPE_NODE) {
+				// nothing to do
+			} else if (nodeType == Node.ELEMENT_NODE) {
+				// element nodes
+				Attr currentAttr = getCurrentAttrNode(currentNode, region.getOffset());
+				if (currentAttr != null){
+					IRegion hyperlinkRegion = getHyperlinkRegion(currentAttr);
+					IHyperlink hyperLink = createHyperlinkForClass(
+							currentAttr.getName(), currentAttr.getNodeValue(), hyperlinkRegion, document);
+					if (hyperLink != null) {
+						return new IHyperlink[] { hyperLink };
+					}
+				}
+			}
+		}
+		return null;
+	}
+	
+	/**
+	 * Returns the attribute node within node at offset
+	 */
+	private Attr getCurrentAttrNode(Node node, int offset) {
+		if ((node instanceof IndexedRegion)
+				&& ((IndexedRegion) node).contains(offset)
+				&& (node.hasAttributes())) {
+			NamedNodeMap attrs = node.getAttributes();
+			// go through each attribute in node and if attribute contains
+			// offset, return that attribute
+			for (int i = 0; i < attrs.getLength(); ++i) {
+				// assumption that if parent node is of type IndexedRegion,
+				// then its attributes will also be of type IndexedRegion
+				IndexedRegion attRegion = (IndexedRegion) attrs.item(i);
+				if (attRegion.contains(offset)) {
+					return (Attr) attrs.item(i);
+				}
+			}
+		}
+		return null;
+	}
+	
+	/**
+	 * Returns the node the cursor is currently on in the document. null if no
+	 * node is selected
+	 * 
+	 * @param offset
+	 * @return Node either element, doctype, text, or null
+	 */
+	private Node getCurrentNode(IDocument document, int offset) {
+		// get the current node at the offset (returns either: element,
+		// doctype, text)
+		IndexedRegion inode = null;
+		IStructuredModel sModel = null;
+		try {
+			sModel = StructuredModelManager.getModelManager()
+					.getExistingModelForRead(document);
+			inode = sModel.getIndexedRegion(offset);
+			if (inode == null)
+				inode = sModel.getIndexedRegion(offset - 1);
+		} finally {
+			if (sModel != null)
+				sModel.releaseFromRead();
+		}
+
+		if (inode instanceof Node) {
+			return (Node) inode;
+		}
+		return null;
+	}
+	
+	private IRegion getHyperlinkRegion(Node node) {
+		IRegion hyperRegion = null;
+
+		if (node != null) {
+			short nodeType = node.getNodeType();
+			if (nodeType == Node.DOCUMENT_TYPE_NODE
+					|| nodeType == Node.ELEMENT_NODE
+					|| nodeType == Node.TEXT_NODE) {
+				// handle doc type node
+				IDOMNode docNode = (IDOMNode) node;
+				hyperRegion = new Region(docNode.getStartOffset(), 
+						docNode.getEndOffset() - docNode.getStartOffset());
+			} else if (nodeType == Node.ATTRIBUTE_NODE) {
+				// handle attribute nodes
+				IDOMAttr att = (IDOMAttr) node;
+				// do not include quotes in attribute value region
+				int regOffset = att.getValueRegionStartOffset();
+				int regLength = att.getValueRegionText().length();
+				String attValue = att.getValueRegionText();
+				if (StringUtils.isQuoted(attValue)) {
+					regOffset = regOffset + 1;
+					regLength = regLength - 2;
+				}
+				hyperRegion = new Region(regOffset, regLength);
+			}
+		}
+		return hyperRegion;
+	}
+	
+	/**
+	 * Create the appropriate hyperlink.
+	 */
+	private IHyperlink createHyperlinkForClass(String name, String target,
+			IRegion hyperlinkRegion, IDocument document) {
+		
+		IHyperlink link = null;
+
+		if (name != null) {
+			if (ClickPlugin.ATTR_CLASSNAME.equals(name)) {
+				try {
+					IFile file = ClickUtils.getResource(document);
+					IJavaProject project = JavaCore.create(file.getProject());
+					IType type = project.findType(target);
+					if (type != null) {
+						link = new AttributeHyperlink(hyperlinkRegion, type);
+					}
+				} catch(Exception ex){
+					ClickPlugin.log(ex);
+				}
+			} else if(ClickPlugin.ATTR_PATH.equals(name)){
+				try {
+					IFile file = ClickUtils.getResource(document);
+					IProject project = file.getProject();
+					String root = ClickUtils.getWebAppRootFolder(project);
+					IFile targetFile = project.getFile(new Path(root).append(target));
+					if(targetFile.exists()){
+						link = new AttributeHyperlink(hyperlinkRegion, targetFile);
+					}
+				} catch(Exception ex){
+					ClickPlugin.log(ex);
+				}
+			}
+		}
+		return link;
+	}
+	
+	/**
+	 * IHyperlink implementation for the java class and other files.
+	 */
+	private class AttributeHyperlink implements IHyperlink {
+
+	    private final IRegion region;
+	    private final IJavaElement element;
+	    private final IFile file;
+
+	    /**
+	     * Creates a new Java element hyperlink.
+	     */
+	    public AttributeHyperlink(IRegion region, IJavaElement element) {
+	        this.region = region;
+	        this.element = element;
+	        this.file = null;
+	    }
+	    
+	    /**
+	     * Creates a new Java element hyperlink.
+	     */
+	    public AttributeHyperlink(IRegion region, IFile file) {
+	        this.region = region;
+	        this.element = null;
+	        this.file = file;
+	    }
+
+	    public IRegion getHyperlinkRegion() {
+	        return this.region;
+	    }
+	    
+	    /**
+	     * opens the standard Java Editor for the given IJavaElement
+	     */
+	    public void open() {
+	        if (this.element != null) {
+                try {
+                    JavaUI.revealInEditor(JavaUI.openInEditor(element), element);
+                } catch (Exception e) {
+                }
+	        }
+	        if(this.file != null){
+	        	try {
+	        		IDE.openEditor(ClickUtils.getActivePage(), file);
+	        	} catch(Exception ex){
+	        	}
+	        }
+	    }
+
+	    public String getTypeLabel() {
+	        return null;
+	    }
+
+	    public String getHyperlinkText() {
+	        return null;
+	    }
+	}
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickXMLTextViewerConfiguration.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickXMLTextViewerConfiguration.java
new file mode 100644
index 0000000..dba5102
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/ClickXMLTextViewerConfiguration.java
@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.jface.text.hyperlink.IHyperlinkDetector;
+import org.eclipse.jface.text.source.ISourceViewer;
+import org.eclipse.wst.xml.ui.StructuredTextViewerConfigurationXML;
+
+/**
+ * Extended StructuredTextViewerConfigurationXML
+ * which provides the hyperlink support for click.xml.
+ * 
+ * @author Naoki Takezoe
+ * @see org.apache.click.eclipse.ui.editor.ClickXMLHyperlinkDetector
+ */
+public class ClickXMLTextViewerConfiguration extends StructuredTextViewerConfigurationXML {
+	
+	public IHyperlinkDetector[] getHyperlinkDetectors(ISourceViewer sourceViewer) {
+		List<IHyperlinkDetector> result = new ArrayList<IHyperlinkDetector>(0);
+		result.add(new ClickXMLHyperlinkDetector());
+		
+		IHyperlinkDetector[] superDetectors = super.getHyperlinkDetectors(sourceViewer);
+		for (int m = 0; m < superDetectors.length; m++) {
+			IHyperlinkDetector detector = superDetectors[m];
+			if (!result.contains(detector)) {
+				result.add(detector);
+			}
+		}
+		
+		return result.toArray(new IHyperlinkDetector[0]);
+	}
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/LineStyleProviderForVelocity.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/LineStyleProviderForVelocity.java
new file mode 100644
index 0000000..0b4684b
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/LineStyleProviderForVelocity.java
@@ -0,0 +1,149 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.eclipse.jface.text.ITypedRegion;
+import org.eclipse.swt.custom.StyleRange;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.wst.html.ui.internal.style.LineStyleProviderForHTML;
+import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocument;
+import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
+import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
+
+/**
+ * The <code>LineStyleProvider</code> implementation for the Velocity template.
+ * <p>
+ * TODO multi-line comment (#* ... *#)
+ * 
+ * @author Naoki Takezoe
+ */
+public class LineStyleProviderForVelocity extends LineStyleProviderForHTML {
+
+	@Override
+	@SuppressWarnings("unchecked")
+	public boolean prepareRegions(ITypedRegion currentRegion, int start, int length, Collection styleRanges) {
+		List<Object> results = new ArrayList<Object>();
+		boolean result = super.prepareRegions(currentRegion, start, length, results);
+
+        // TODO Is it possible to update colors when preferences changed...?
+    	Color colorVariable  = ClickPlugin.getDefault().getColorManager().get(ClickPlugin.PREF_COLOR_VAR);
+    	Color colorDirective = ClickPlugin.getDefault().getColorManager().get(ClickPlugin.PREF_COLOR_DIR);
+    	Color colorComment   = ClickPlugin.getDefault().getColorManager().get(ClickPlugin.PREF_COLOR_CMT);
+
+        IStructuredDocument document = getDocument();
+        
+        for(Iterator ite = results.iterator(); ite.hasNext();){
+            StyleRange styleRange = (StyleRange)ite.next();
+            
+            IStructuredDocumentRegion region = document.getRegionAtCharacterOffset(styleRange.start);
+            String text = region.getText();
+            int mStart = styleRange.start - region.getStartOffset();
+            int mEnd = mStart + styleRange.length;
+            for(IStructuredDocumentRegion chkRegion = region.getPrevious(); chkRegion != null; chkRegion = chkRegion.getPrevious()){
+                String type = chkRegion.getType();
+                if(!type.equals(DOMRegionContext.XML_CONTENT) && !type.equals(DOMRegionContext.UNDEFINED)){
+                    break;
+                }
+                text = chkRegion.getText() + text;
+                mStart += chkRegion.getLength();
+                mEnd   += chkRegion.getLength();
+            }
+
+            for(IStructuredDocumentRegion chkRegion = region.getNext(); chkRegion != null; chkRegion = chkRegion.getNext()){
+                String type = chkRegion.getType();
+                if(!type.equals(DOMRegionContext.XML_CONTENT) && !type.equals(DOMRegionContext.UNDEFINED)){
+                    break;
+                }
+                text = (new StringBuilder(String.valueOf(text))).append(chkRegion.getText()).toString();
+            }
+
+            Pattern p = Pattern.compile("##.*|#[a-z]+|\\$((\\{.*?\\})|([a-zA-Z0-9\\-_]*))");
+            Matcher m = p.matcher(text);
+            int pos = 0;
+            while(m.find()) {
+            	Color color = m.group().startsWith("##") ? colorComment : 
+            		          m.group().startsWith("#") ? colorDirective : colorVariable;
+            	
+                if(m.start() < mStart){
+                    if(m.end() < mStart){
+                        continue;
+                    }
+                    StyleRange curr;
+                    if(m.end() < mEnd){
+                        curr = (StyleRange)styleRange.clone();
+                        curr.start = styleRange.start;
+                        curr.length = m.end() - mStart;
+                        curr.foreground = color;
+                        styleRanges.add(curr);
+                        pos = m.end() - mStart;
+                        continue;
+                    }
+                    curr = (StyleRange)styleRange.clone();
+                    curr.foreground = color;
+                    styleRanges.add(curr);
+                    pos = m.end();
+                    break;
+                }
+                if(m.start() >= mEnd){
+                    break;
+                }
+                if(m.start() > mStart && pos == 0){
+                    StyleRange prev = (StyleRange)styleRange.clone();
+                    prev.start = styleRange.start;
+                    prev.length = m.start() - mStart;
+                    styleRanges.add(prev);
+                    pos = m.end() - mStart;
+                }
+                if(m.end() < mEnd){
+                    StyleRange curr = (StyleRange)styleRange.clone();
+                    curr.start = (styleRange.start + m.start()) - mStart;
+                    curr.length = m.end() - m.start();
+                    curr.foreground = color;
+                    styleRanges.add(curr);
+                    pos = m.end() - mStart;
+                } else {
+                    StyleRange curr = (StyleRange)styleRange.clone();
+                    curr.start = (styleRange.start + m.start()) - mStart;
+                    curr.length = (styleRange.length - m.start()) + mStart;
+                    curr.foreground = color;
+                    styleRanges.add(curr);
+                    pos = m.end() - mStart;
+                }
+            }
+            if(pos < styleRange.length){
+                StyleRange post = (StyleRange)styleRange.clone();
+                post.start = styleRange.start + pos;
+                post.length = styleRange.length - pos;
+                styleRanges.add(post);
+            }
+            //styleRanges.remove(styleRange);
+        }
+
+        return result;
+	}
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateAutoEditStrategy.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateAutoEditStrategy.java
new file mode 100644
index 0000000..3e25636
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateAutoEditStrategy.java
@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.DocumentCommand;
+import org.eclipse.jface.text.IAutoEditStrategy;
+import org.eclipse.jface.text.IDocument;
+
+/**
+ * {@link IAutoEditStrategy} implementation for the {@link TemplateEditor}.
+ * 
+ * @see TemplateEditor
+ * @see TemplateEditorConfiguration
+ * 
+ * @author Naoki Takezoe
+ */
+public class TemplateAutoEditStrategy implements IAutoEditStrategy {
+
+	public void customizeDocumentCommand(IDocument document, DocumentCommand command) {
+		try {
+			// ${}
+			if(command.text.equals("{") && command.offset > 1 
+					&& document.get(command.offset - 1, 1).equals("$")){
+				command.text = command.text + "}";
+				command.caretOffset = command.offset + 1;
+				command.shiftsCaret = false;
+				command.doit = false;
+			}
+		} catch(BadLocationException ex){
+			ClickPlugin.log(ex);
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateContentAssistProcessor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateContentAssistProcessor.java
new file mode 100644
index 0000000..cbe0831
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateContentAssistProcessor.java
@@ -0,0 +1,421 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor;
+
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.preferences.ClickProjectPropertyPage.VariableModel;
+import org.apache.click.eclipse.ui.editor.TemplateObject.TemplateObjectElement;
+import org.apache.click.eclipse.ui.editor.TemplateObject.TemplateObjectMethod;
+import org.apache.click.eclipse.ui.editor.TemplateObject.TemplateObjectProperty;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.ProjectScope;
+import org.eclipse.jdt.core.Flags;
+import org.eclipse.jdt.core.IField;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.Signature;
+import org.eclipse.jface.text.ITextViewer;
+import org.eclipse.jface.text.contentassist.CompletionProposal;
+import org.eclipse.jface.text.contentassist.ICompletionProposal;
+import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.ui.preferences.ScopedPreferenceStore;
+import org.eclipse.wst.xml.ui.internal.contentassist.XMLContentAssistProcessor;
+
+/**
+ * {@link IContentAssistProcessor} implementation for the Velocity Template Editor.
+ * 
+ * @author Naoki Takezoe
+ */
+public class TemplateContentAssistProcessor extends XMLContentAssistProcessor {
+	
+	private IFile file;
+	
+	private final Image IMAGE_DIRECTIVE = ClickPlugin.getImageDescriptor("/icons/directive.gif").createImage();
+	private final Image IMAGE_METHOD = ClickPlugin.getImageDescriptor("/icons/method.gif").createImage();
+	private final Image IMAGE_FIELD = ClickPlugin.getImageDescriptor("/icons/field.gif").createImage();
+	private final Image IMAGE_VAR = ClickPlugin.getImageDescriptor("/icons/localvar.gif").createImage();
+	
+	private final Pattern PATTERN_SET = Pattern.compile("#set\\s*\\(\\s*\\$(.+?)\\s*=");
+	private final Pattern PATTERN_MACRO = Pattern.compile("#macro\\s*\\(\\s*(.+?)[\\s\\)]");
+	
+	private static final Map<String, String> defaultObjects = new HashMap<String, String>();
+	static {
+		defaultObjects.put("imports", "org.apache.click.util.PageImports");
+		defaultObjects.put("context", "java.lang.String");
+		defaultObjects.put("messages", "java.util.Map");
+		defaultObjects.put("path", "java.lang.String");
+		defaultObjects.put("request", "javax.servlet.http.HttpServletRequest");
+		defaultObjects.put("response", "javax.servlet.http.HttpServletResponse");
+		defaultObjects.put("session", "org.apache.click.util.SessionMap");
+	};
+	
+	/**
+	 * Returns the word under the caret position.
+	 */
+	private static String getLastWord(ITextViewer textViewer, int documentPosition){
+		String source = textViewer.getDocument().get();
+		StringBuffer sb = new StringBuffer();
+		for(int i=0;i<documentPosition;i++){
+			char c = source.charAt(i);
+			if(Character.isWhitespace(c)){
+				sb.setLength(0);
+			} else if(c=='#' || c=='$'){
+				sb.setLength(0);
+				sb.append(c);
+			} else {
+				sb.append(c);
+			}
+		}
+		return sb.toString();
+	}
+	
+	/**
+	 * Appends the completion proposal to the <code>result</code>.
+	 */
+	private static void registerProposal(List<ICompletionProposal> result, int offset, 
+			String matchString, String replaceString, String displayString, Image image){
+		int position = replaceString.length();
+		if(replaceString.endsWith(")") && displayString.indexOf("()") < 0){
+			position--;
+		}
+		if(replaceString.endsWith("}") && displayString.indexOf("{}") < 0){
+			position--;
+		}
+		if(replaceString.startsWith(matchString)){
+			result.add(new CompletionProposal(
+			        replaceString, offset - matchString.length(), 
+			        matchString.length(), position, image, displayString, null, null));
+		}
+		if(matchString.startsWith("${") && replaceString.startsWith("$") &&
+				!replaceString.startsWith("${")){
+			registerProposal(result, offset, matchString, 
+					"${" + replaceString.substring(1), displayString, image);
+		}
+	}
+	
+	/**
+	 * Returns completion proposals.
+	 */
+	public ICompletionProposal[] computeCompletionProposals(ITextViewer textViewer, int offset) {
+		
+		String matchString = getLastWord(textViewer, offset);
+		List<ICompletionProposal> result = new ArrayList<ICompletionProposal>();
+		
+		if(!matchString.startsWith("#") && !matchString.startsWith("$")){
+			ICompletionProposal[] proposals = super.computeCompletionProposals(textViewer, offset);
+			if(proposals!=null){
+				for(int i=0;i<proposals.length;i++){
+					result.add(proposals[i]);
+				}
+			}
+		}
+		
+		IType format = null;
+		List<VariableModel> preferenceObjects = null;
+		
+		if(this.file != null){
+			// for the format object
+			format = ClickUtils.getFormat(file.getProject());
+			if(matchString.startsWith("$format.") || matchString.startsWith("${format.")){
+				if(format != null){
+					return processType(format, result, matchString, offset);
+				}
+			}
+			// other default objects
+			for(Iterator<Map.Entry<String, String>> ite = defaultObjects.entrySet().iterator(); ite.hasNext(); ){
+				Map.Entry<String, String> entry = ite.next();
+				if(matchString.startsWith("$" + entry.getKey() + ".") || matchString.startsWith("${" + entry.getKey() + ".")){
+					IType type = findType((String)entry.getValue());
+					if(type != null){
+						return processType(type, result, matchString, offset);
+					}
+				}
+			}
+			// prefeberce objects
+			ScopedPreferenceStore store = new ScopedPreferenceStore(
+					new ProjectScope(file.getProject()), ClickPlugin.PLUGIN_ID);
+			String vars = store.getString(ClickPlugin.PREF_VELOCITY_VARS);
+			if(vars != null && vars.length() > 0){
+				preferenceObjects = VariableModel.deserialize(vars);
+				for(int i=0;i<preferenceObjects.size();i++){
+					VariableModel model = preferenceObjects.get(i);
+					if(matchString.startsWith("$" + model.name + ".") || matchString.startsWith("${" + model.name + ".")){
+						IType type = findType((String)model.type);
+						if(type != null){
+							return processType(type, result, matchString, offset);
+						}
+					}
+				}
+			}
+		}
+		
+		Map<String, TemplateObject> fields = extractPageFields();
+		for(Iterator<Map.Entry<String, TemplateObject>> ite = fields.entrySet().iterator(); ite.hasNext();){
+			Map.Entry<String, TemplateObject> entry = ite.next();
+			String name = entry.getKey();
+			if(matchString.startsWith("$" + name + ".") || matchString.startsWith("${" + name + ".")){
+				TemplateObject obj = (TemplateObject)entry.getValue();
+				if(obj.getType()!=null){
+					return processType(obj.getType(), result, matchString, offset);
+				}
+			}
+		}
+		
+		if(format==null){
+			registerProposal(result, offset, matchString, "$format", "$format", IMAGE_VAR);
+		} else {
+			registerProposal(result, offset, matchString, 
+					"$format", "$format - " + format.getFullyQualifiedName(), IMAGE_VAR);
+		}
+		
+		// for page class fields
+		for(Iterator<Map.Entry<String, TemplateObject>> ite = fields.entrySet().iterator(); ite.hasNext();){
+			Map.Entry<String, TemplateObject> entry = ite.next();
+			String name = entry.getKey();
+			TemplateObject obj = (TemplateObject)entry.getValue();
+			registerProposal(result, offset, matchString, 
+				"$" + name, "$" + name + " - " + obj.getTypeName(), IMAGE_FIELD);
+		}
+		
+		// #set($xxxx)
+		String source = textViewer.getDocument().get().substring(0, offset);
+		Matcher matcher = PATTERN_SET.matcher(source);
+		while(matcher.find()){
+			String name = matcher.group(1);
+			registerProposal(result, offset, matchString, "$" + name, "$" + name, IMAGE_VAR);
+		}
+		
+		// #macro(xxxx)
+		matcher = PATTERN_MACRO.matcher(source);
+		while(matcher.find()){
+			String name = matcher.group(1);
+			registerProposal(result, offset, matchString, "#" + name + "()", name, IMAGE_DIRECTIVE);
+		}
+		readMacroVM(result, offset, matchString);
+		
+		registerProposal(result, offset, matchString, "$imports", "$imports - PageImports", IMAGE_VAR);
+		registerProposal(result, offset, matchString, "$context", "$context - String", IMAGE_VAR);
+		registerProposal(result, offset, matchString, "$messages", "$messages - Map", IMAGE_VAR);
+		registerProposal(result, offset, matchString, "$path", "$path - String", IMAGE_VAR);
+		registerProposal(result, offset, matchString, "$request", "$request - HttpServletRequest", IMAGE_VAR);
+		registerProposal(result, offset, matchString, "$response", "$response - HttpServletResponse", IMAGE_VAR);
+		registerProposal(result, offset, matchString, "$session", "$session - SessionMap", IMAGE_VAR);
+		
+		if(preferenceObjects != null){
+			for(int i=0;i<preferenceObjects.size();i++){
+				VariableModel model = (VariableModel) preferenceObjects.get(i);
+				registerProposal(result, offset, matchString, 
+						"$" + model.name, "$" + model.name + " - " + model.type, IMAGE_VAR);
+			}
+		}
+		
+		registerProposal(result, offset, matchString, "#if()", "if", IMAGE_DIRECTIVE);
+		registerProposal(result, offset, matchString, "#set()", "set", IMAGE_DIRECTIVE);
+		registerProposal(result, offset, matchString, "#foreach()", "foreach", IMAGE_DIRECTIVE);
+		registerProposal(result, offset, matchString, "#else", "else", IMAGE_DIRECTIVE);
+		registerProposal(result, offset, matchString, "#elseif()", "elsif", IMAGE_DIRECTIVE);
+		registerProposal(result, offset, matchString, "#end", "end", IMAGE_DIRECTIVE);
+		registerProposal(result, offset, matchString, "#include()", "include", IMAGE_DIRECTIVE);
+		registerProposal(result, offset, matchString, "#parse()", "parse", IMAGE_DIRECTIVE);
+		registerProposal(result, offset, matchString, "#macro()", "macro", IMAGE_DIRECTIVE);
+		
+		
+		return (ICompletionProposal[])result.toArray(new ICompletionProposal[result.size()]);
+	}
+	
+	private IType findType(String className){
+		try {
+			IJavaProject project = JavaCore.create(this.file.getProject());
+			if(project != null){
+				IType type = project.findType(className);
+				return type;
+			}
+		} catch(Exception ex){
+		}
+		return null;
+	}
+	
+	/**
+	 * Read macro.vm and add macros to completion proposals.
+	 */
+	private void readMacroVM(List<ICompletionProposal> result, int offset, String matchString){
+		IProject project = this.file.getProject();
+		String folderName = ClickUtils.getWebAppRootFolder(project);
+		IFolder folder = project.getFolder(folderName);
+		IFile macroFile = folder.getFile("macro.vm");
+		if(macroFile!=null && macroFile.exists()){
+			try {
+				InputStream in = macroFile.getContents();
+				byte[] buf = new byte[in.available()];
+				in.read(buf);
+				in.close();
+				
+				String source = new String(buf, macroFile.getCharset());
+				Matcher matcher = PATTERN_MACRO.matcher(source);
+				while(matcher.find()){
+					String name = matcher.group(1);
+					registerProposal(result, offset, matchString, "#" + name + "()", 
+							name + " - macro.vm", IMAGE_DIRECTIVE);
+				}
+				
+			} catch(Exception ex){
+				ClickPlugin.log(ex);
+			}
+		}
+	}
+	
+	/**
+	 * Returns completion proposals for the java object.
+	 */
+	private ICompletionProposal[] processType(IType type, List<ICompletionProposal> result, String matchString, int offset){
+		String prefix = matchString;
+		int index = matchString.lastIndexOf('.');
+		if(index >= 0){
+			prefix = prefix.substring(0, index);
+		}
+		
+		TemplateObject obj = new TemplateObject(type);
+		obj = evaluate(obj, matchString);
+		if(obj != null){
+			TemplateObjectElement[] children = obj.getChildren();
+			for(int i=0;i<children.length;i++){
+				if(children[i] instanceof TemplateObjectMethod){
+					registerProposal(result, offset, matchString, 
+							prefix + "." + children[i].getName()+"()", children[i].getDisplayName(), IMAGE_METHOD);
+				} else {
+					registerProposal(result, offset, matchString, 
+							prefix + "." + children[i].getName(), children[i].getDisplayName(), IMAGE_FIELD);
+				}
+			}
+		}
+		return result.toArray(new ICompletionProposal[result.size()]);
+	}
+	
+	/**
+	 * Evaluates the given expression and returns the return type.
+	 * 
+	 * @param obj the <code>TemplateObject</code> of the top level object
+	 * @param expression the Velocity expression
+	 * @return the return type of the given expression or <code>null</code>
+	 */
+	private TemplateObject evaluate(TemplateObject obj, String expression){
+		if(expression.endsWith(".")){
+			expression += "_";
+		}
+		String[] dim = expression.split("\\.");
+		for(int i=0; i < dim.length && obj != null; i++){
+			if(i == 0 || i == dim.length-1){
+				continue;
+			}
+			if(dim[i].endsWith(")")){
+				// method
+				String[] methodInfo = dim[i].split("\\(");
+				if(methodInfo.length > 0){
+					TemplateObjectMethod method = obj.getMethod(methodInfo[0]);
+					if(method != null){
+						obj = method.toTemplateObject();
+						continue;
+					}
+				}
+			} else {
+				// property
+				TemplateObjectProperty property = obj.getProperty(dim[i]);
+				if(property != null){
+					obj = property.toTemplateObject();
+					continue;
+				}
+			}
+			obj = null;
+		}
+		return obj;
+	}
+	
+	/**
+	 * Extracts public fields from the page class.
+	 */
+	private Map<String, TemplateObject> extractPageFields(){
+		HashMap<String, TemplateObject> map = new HashMap<String, TemplateObject>();
+		if(this.file != null){
+			try {
+				IType type = ClickUtils.getPageClassFromTemplate(this.file);
+				IJavaProject javaProject = type.getJavaProject();
+				
+				IField[] fields = type.getFields();
+				for(int i=0;i<fields.length;i++){
+					if(!Flags.isPublic(fields[i].getFlags())){
+						continue;
+					}
+					String className = ClickUtils.removeTypeParameter(Signature.toString(fields[i].getTypeSignature()));
+					// primitive types
+					if(ClickUtils.isPrimitive(className)){
+						TemplateObject obj = new TemplateObject(className);
+						map.put(fields[i].getElementName(), obj);
+						continue;
+					}
+					// object types
+					className = ClickUtils.resolveClassName(type, className);
+					IType fieldType = javaProject.findType(className);
+					if(fieldType != null){
+						TemplateObject obj = new TemplateObject(fieldType);
+						map.put(fields[i].getElementName(), obj);
+					}
+				}
+			} catch(Exception ex){
+				//ClickPlugin.log(ex);
+			}
+		}
+		return map;
+	}
+	
+	/**
+	 * Sets the editing filr in the editor.
+	 * 
+	 * @param file the editing file
+	 */
+	public void setFile(IFile file){
+		this.file = file;
+	}
+	
+	/**
+	 * Releases internal resources such as icons.
+	 */
+	public void release() {
+		IMAGE_DIRECTIVE.dispose();
+		IMAGE_METHOD.dispose();
+		IMAGE_FIELD.dispose();
+		IMAGE_VAR.dispose();
+		super.release();
+	}
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateEditor.java
new file mode 100644
index 0000000..6a5ba1b
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateEditor.java
@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor;
+
+
+import org.apache.click.eclipse.core.validator.TemplateValidator;
+import org.apache.click.eclipse.ui.actions.ToggleCommentAction;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IFileEditorInput;
+import org.eclipse.ui.texteditor.ITextEditorActionConstants;
+import org.eclipse.wst.sse.ui.StructuredTextEditor;
+
+/**
+ * The editor for page templates which uses Velocity.
+ * <p>
+ * This editor extends WTP HTML editor and provides
+ * some new features for Velocity.
+ *
+ * <ul>
+ *   <li>Code completion for Velocity directives and the $format object</li>
+ *   <li>Velocity syntax validation by {@link TemplateValidator}</li>
+ *   <li>Syntax highlighting for Velocity directives</li>
+ *   <li>Code completion for the Page public fields as variables</li>
+ *   <li>TODO Code completion for the variables which declared by the #set directive</li>
+ * </ul>
+ *
+ * @author Naoki Takezoe
+ */
+public class TemplateEditor extends StructuredTextEditor {
+
+	protected void createActions() {
+		super.createActions();
+		setAction(ToggleCommentAction.class.getName(), new ToggleCommentAction(this));
+	}
+
+	protected void addContextMenuActions(IMenuManager menu){
+		super.addContextMenuActions(menu);
+		addAction(menu, ITextEditorActionConstants.GROUP_EDIT, ToggleCommentAction.class.getName());
+	}
+
+	protected void doSetInput(IEditorInput input) throws CoreException {
+		super.doSetInput(input);
+
+		setSourceViewerConfiguration(new TemplateEditorConfiguration());
+
+		TemplateEditorConfiguration config
+			= (TemplateEditorConfiguration)getSourceViewerConfiguration();
+		IContentAssistProcessor[] processors
+			= config.getContentAssistProcessors(null, null);
+		TemplateContentAssistProcessor processor
+			= (TemplateContentAssistProcessor)processors[0];
+
+		if(input instanceof IFileEditorInput){
+			processor.setFile(((IFileEditorInput)input).getFile());
+		} else {
+			processor.setFile(null);
+		}
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateEditorActionContributor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateEditorActionContributor.java
new file mode 100644
index 0000000..5bee646
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateEditorActionContributor.java
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ui.actions.ToggleCommentAction;
+import org.eclipse.jface.action.IAction;
+import org.eclipse.jface.action.IMenuManager;
+import org.eclipse.jface.action.Separator;
+import org.eclipse.swt.SWT;
+import org.eclipse.ui.IActionBars;
+import org.eclipse.ui.IEditorPart;
+import org.eclipse.ui.texteditor.ITextEditor;
+import org.eclipse.ui.texteditor.RetargetTextEditorAction;
+import org.eclipse.wst.html.ui.internal.edit.ui.ActionContributorHTML;
+
+public class TemplateEditorActionContributor extends ActionContributorHTML {
+
+	private List<String> actionIds = new ArrayList<String>();
+	private List<IAction> actions = new ArrayList<IAction>();
+
+	public TemplateEditorActionContributor(){
+		actionIds.add(ToggleCommentAction.class.getName());
+	}
+
+	public void setActiveEditor(IEditorPart part) {
+		super.setActiveEditor(part);
+		doSetActiveEditor(part);
+	}
+
+	private void doSetActiveEditor(IEditorPart part) {
+		ITextEditor textEditor= null;
+		if (part instanceof ITextEditor){
+			textEditor = (ITextEditor) part;
+		}
+		if(textEditor!=null){
+			for(int i=0;i<this.actions.size();i++){
+				RetargetTextEditorAction action = (RetargetTextEditorAction) actions.get(i);
+				IAction targetAction = textEditor.getAction((String) actionIds.get(i));
+				if(targetAction!=null){
+					action.setAccelerator(targetAction.getAccelerator());
+					action.setAction(targetAction);
+				} else {
+					action.setAccelerator(SWT.NULL);
+					action.setAction(null);
+				}
+			}
+		}
+	}
+
+	public void init(IActionBars bars) {
+		super.init(bars);
+
+		IMenuManager menuManager = bars.getMenuManager();
+		IMenuManager editMenu = menuManager.findMenuUsingPath("edit");
+		if(editMenu!=null){
+			editMenu.insertBefore("additions", new Separator("clickide"));
+
+			if (editMenu != null) {
+				for(int i=0;i<actionIds.size();i++){
+					RetargetTextEditorAction action = new RetargetTextEditorAction(
+							ClickPlugin.getDefault().getResourceBundle(), null);
+					this.actions.add(action);
+					editMenu.appendToGroup("clickide", action);
+				}
+			}
+		}
+	}
+
+
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateEditorConfiguration.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateEditorConfiguration.java
new file mode 100644
index 0000000..6945bff
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateEditorConfiguration.java
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.jface.text.IAutoEditStrategy;
+import org.eclipse.jface.text.contentassist.IContentAssistProcessor;
+import org.eclipse.jface.text.source.ISourceViewer;
+import org.eclipse.jface.text.source.SourceViewerConfiguration;
+import org.eclipse.wst.html.core.text.IHTMLPartitions;
+import org.eclipse.wst.html.ui.StructuredTextViewerConfigurationHTML;
+import org.eclipse.wst.sse.ui.internal.provisional.style.LineStyleProvider;
+
+/**
+ * {@link SourceViewerConfiguration} for the Velocity Template Editor.
+ * Provides the extended code completion for Velocity.
+ * 
+ * @author Naoki Takezoe
+ * @see TemplateContentAssistProcessor
+ */
+public class TemplateEditorConfiguration extends StructuredTextViewerConfigurationHTML {
+	
+	private TemplateContentAssistProcessor processor = null;
+	
+	/**
+	 * @see TemplateContentAssistProcessor
+	 */
+	protected IContentAssistProcessor[] getContentAssistProcessors(ISourceViewer viewer, String partitionType) {
+		if(this.processor == null){
+			this.processor = new TemplateContentAssistProcessor();
+		}
+		return new IContentAssistProcessor[]{this.processor};
+	}
+
+	/**
+	 * @see TemplateAutoEditStrategy
+	 */
+	public IAutoEditStrategy[] getAutoEditStrategies(ISourceViewer sourceViewer, String contentType) {
+		List<IAutoEditStrategy> allStrategies = new ArrayList<IAutoEditStrategy>(0);
+		
+		IAutoEditStrategy[] superStrategies = super.getAutoEditStrategies(sourceViewer, contentType);
+		for (int i = 0; i < superStrategies.length; i++) {
+			allStrategies.add(superStrategies[i]);
+		}
+		
+		allStrategies.add(new TemplateAutoEditStrategy());
+
+		return allStrategies.toArray(new IAutoEditStrategy[allStrategies.size()]);
+	}
+	
+	/**
+	 * @see LineStyleProviderForVelocity
+	 */
+	public LineStyleProvider[] getLineStyleProviders(ISourceViewer sourceViewer, String partitionType) {
+		LineStyleProvider[] providers = null;
+
+		if (partitionType == IHTMLPartitions.HTML_DEFAULT || partitionType == IHTMLPartitions.HTML_COMMENT || partitionType == IHTMLPartitions.HTML_DECLARATION) {
+			providers = new LineStyleProvider[]{new LineStyleProviderForVelocity()};
+		} else {
+			providers = super.getLineStyleProviders(sourceViewer, partitionType);
+		}
+//		else if (partitionType == IHTMLPartitions.SCRIPT) {
+//			providers = new LineStyleProvider[]{getLineStyleProviderForJavascript()};
+//		}
+//		else if (partitionType == ICSSPartitions.STYLE) {
+//			providers = new LineStyleProvider[]{getLineStyleProviderForEmbeddedCSS()};
+//		}
+
+		return providers;
+	}
+	
+	
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateObject.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateObject.java
new file mode 100644
index 0000000..7807cd3
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/TemplateObject.java
@@ -0,0 +1,476 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.jdt.core.Flags;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IMethod;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.ITypeHierarchy;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jdt.core.Signature;
+
+/**
+ * Provides accessors which are easy to use for JDT class model.
+ * This class would be used by the code completion in the Velocity editor.
+ * 
+ * @author Naoki Takezoe
+ * @see TemplateContentAssistProcessor
+ */
+public class TemplateObject {
+	
+	private IType type;
+	private String primitiveType;
+	
+	/**
+	 * The constructor.
+	 * 
+	 * @param type the <code>IType</code> object
+	 */
+	public TemplateObject(IType type){
+		this.type = type;
+	}
+	
+	/**
+	 * The constructor for primitive types.
+	 * 
+	 * @param primitiveType the primitive type name
+	 */
+	public TemplateObject(String primitiveType){
+		this.primitiveType = primitiveType;
+	}
+	
+	/**
+	 * Returns the specified method.
+	 * If this object doesn't have the specified method, returns <code>null</code>.
+	 * 
+	 * @param name the method name
+	 * @return the specified method or <code>null</code>
+	 */
+	public TemplateObjectMethod getMethod(String name){
+		if(this.type!=null){
+			TemplateObjectMethod[] methods = getMethods();
+			for(int i=0;i<methods.length;i++){
+				if(methods[i].getName().equals(name)){
+					return methods[i];
+				}
+			}
+		}
+		return null;
+	}
+	
+	/**
+	 * Returns the specified property.
+	 * If this object doesn't have the specified property, returns <code>null</code>.
+	 * 
+	 * @param name the property name
+	 * @return the specified property or <code>null</code>
+	 */
+	public TemplateObjectProperty getProperty(String name){
+		if(this.type!=null){
+			TemplateObjectProperty[] properties = getProperties();
+			for(int i=0;i<properties.length;i++){
+				if(properties[i].getName().equals(name)){
+					return properties[i];
+				}
+			}
+		}
+		return null;
+	}
+	
+	/**
+	 * Returns available methods in this object.
+	 * 
+	 * @return the array of methods
+	 */
+	public TemplateObjectMethod[] getMethods(){
+		if(this.type!=null){
+			try {
+				IMethod[] methods = getAllMethods(type);
+				List<TemplateObjectMethod> result = new ArrayList<TemplateObjectMethod>();
+				for(int i=0;i<methods.length;i++){
+					if(Flags.isPublic(methods[i].getFlags()) && !methods[i].isConstructor()){
+						result.add(new TemplateObjectMethod(methods[i]));
+					}
+				}
+				return result.toArray(new TemplateObjectMethod[result.size()]);
+			} catch (JavaModelException e) {
+			}
+		}
+		return new TemplateObjectMethod[0];
+	}
+	
+	/**
+	 * Returns available fields in this object.
+	 * 
+	 * @return the array of properties
+	 */
+	public TemplateObjectProperty[] getProperties(){
+		if(this.type!=null){
+			try {
+				IMethod[] methods = getAllMethods(type);
+				List<TemplateObjectProperty> result = new ArrayList<TemplateObjectProperty>();
+				for(int i=0;i<methods.length;i++){
+					if(Flags.isPublic(methods[i].getFlags()) && methods[i].getParameterTypes().length==0){
+						String name = methods[i].getElementName();
+						if((name.startsWith("get") && name.length() > 3) || 
+								(name.startsWith("is") && name.length() > 2)){
+							result.add(new TemplateObjectProperty(methods[i]));
+						}
+					}
+				}
+				return result.toArray(new TemplateObjectProperty[result.size()]);
+			} catch (JavaModelException e) {
+			}
+		}
+		return new TemplateObjectProperty[0];
+	}
+	
+	/**
+	 * Returns available methods and fields in this object.
+	 * 
+	 * @return the array of both methods and properties
+	 */
+	public TemplateObjectElement[] getChildren(){
+		List<TemplateObjectElement> result = new ArrayList<TemplateObjectElement>();
+		if(this.type!=null){
+			TemplateObjectMethod[] methods = getMethods();
+			TemplateObjectProperty[] properties = getProperties();
+			for(int i=0;i<methods.length;i++){
+				result.add(methods[i]);
+			}
+			for(int i=0;i<properties.length;i++){
+				result.add(properties[i]);
+			}
+			Collections.sort(result, new Comparator<TemplateObjectElement>(){
+				public int compare(TemplateObjectElement arg0, TemplateObjectElement arg1) {
+					return arg0.toString().compareTo(arg1.toString());
+				}
+			});
+		}
+		return (TemplateObjectElement[])result.toArray(new TemplateObjectElement[result.size()]);
+	}
+	
+	/**
+	 * Tests whether this object is the primitive type.
+	 * 
+	 * @return <code>true</code> if this is the primitive type; 
+	 *   <code>false</code> otherwise
+	 */
+	public boolean isPrimitive(){
+		return this.type == null;
+	}
+	
+	/**
+	 * Returns the <code>IType</code> instance of this object.
+	 * 
+	 * @return the <code>IType</code> instance.
+	 *   If this object is the primitive type, returns null.
+	 */
+	public IType getType(){
+		return this.type;
+	}
+	
+	/**
+	 * Returns the type name of this object.
+	 * 
+	 * @return the full qualified class name or the primitive type name
+	 */
+	public String getTypeName(){
+		if(this.type!=null){
+			return this.type.getFullyQualifiedName();
+		} else {
+			return this.primitiveType;
+		}
+	}
+	
+	///////////////////////////////////////////////////////////////////////////////////////
+	//
+	// Inner Classes
+	//
+	///////////////////////////////////////////////////////////////////////////////////////
+	/**
+	 * The <code>TemplateObjectElement</code> implementation which expresses
+	 * the proprty of <code>TemplateObject</code>
+	 */
+	public static class TemplateObjectProperty implements TemplateObjectElement {
+		
+		private IMethod method;
+		
+		public TemplateObjectProperty(IMethod method){
+			this.method = method;
+		}
+		
+		public String getName(){
+			String name = this.method.getElementName();
+			if(name.startsWith("get")){
+				name = name.substring(3);
+			} else if(name.startsWith("is")){
+				name = name.substring(2);
+			}
+			return name.substring(0, 1).toLowerCase() + name.substring(1);
+		}
+		
+		public String getDisplayName(){
+			StringBuffer sb = new StringBuffer();
+			sb.append(getName());
+			sb.append(" ");
+			try {
+				sb.append(getSimpleName(Signature.toString(this.method.getReturnType())));
+			} catch(Exception ex){
+			}
+			sb.append(" - ");
+			sb.append(this.method.getDeclaringType().getElementName());
+			return sb.toString();
+		}
+		
+		/**
+		 * Returns the <code>TemplateObject</code> by the property type.
+		 */
+		public TemplateObject toTemplateObject(){
+			try {
+				String className = ClickUtils.removeTypeParameter(Signature.toString(this.method.getReturnType()));
+				if(ClickUtils.isPrimitive(className)){
+					return null;
+				}
+				className = ClickUtils.resolveClassName(method.getDeclaringType(), className);
+				IJavaProject javaProject = method.getDeclaringType().getJavaProject();
+				IType type = javaProject.findType(className);
+				if(type!=null && type.exists()){
+					return new TemplateObject(type);
+				}
+			} catch(Exception ex){
+			}
+			return null;
+		}
+		
+		public String toString(){
+			return getDisplayName();
+		}
+	}
+	
+	/**
+	 * The <code>TemplateObjectElement</code> implementation which expresses
+	 * the method of <code>TemplateObject</code>
+	 */
+	public static class TemplateObjectMethod implements TemplateObjectElement {
+		
+		private IMethod method;
+		
+		public TemplateObjectMethod(IMethod method){
+			this.method = method;
+		}
+		
+		public String getName(){
+			return this.method.getElementName();
+		}
+		
+//		public int getArgumentCount(){
+//			return this.method.getParameterTypes().length;
+//		}
+		
+		public String getDisplayName(){
+			StringBuffer sb = new StringBuffer();
+			sb.append(getName());
+			sb.append("(");
+			String[] types = this.method.getParameterTypes();
+			String[] names = null;
+			try {
+				names = this.method.getParameterNames();
+			} catch(Exception ex){
+				names = new String[types.length];
+				for(int i=0;i<names.length;i++){
+					names[i] = "arg" + i;
+				}
+			}
+			for(int i=0;i<types.length;i++){
+				if(i != 0){
+					sb.append(", ");
+				}
+				sb.append(getSimpleName(Signature.toString(types[i])));
+				sb.append(" ");
+				sb.append(names[i]);
+			}
+			sb.append(") ");
+			try {
+				sb.append(getSimpleName(Signature.toString(method.getReturnType())));
+			} catch(Exception ex){
+			}
+			sb.append(" - ");
+			sb.append(method.getDeclaringType().getElementName());
+			return sb.toString();
+		}
+		
+		/**
+		 * Returns the <code>TemplateObject</code> by the return type of the method.
+		 */
+		public TemplateObject toTemplateObject(){
+			// TODO This implementation is same to TemplateObjectProperty.
+			try {
+				String className = ClickUtils.removeTypeParameter(Signature.toString(this.method.getReturnType()));
+				if(ClickUtils.isPrimitive(className)){
+					return null;
+				}
+				className = ClickUtils.resolveClassName(method.getDeclaringType(), className);
+				IJavaProject javaProject = method.getDeclaringType().getJavaProject();
+				IType type = javaProject.findType(className);
+				if(type!=null && type.exists()){
+					return new TemplateObject(type);
+				}
+			} catch(Exception ex){
+			}
+			return null;
+		}
+		
+		public String toString(){
+			return getDisplayName();
+		}
+	}
+	
+	/**
+	 * The interface of <code>TemplateObject</code> elements,
+	 * expresses methods and properties.
+	 */
+	public static interface TemplateObjectElement {
+		
+		/**
+		 * Returns the element name.
+		 * 
+		 * @return the element name
+		 */
+		public String getName();
+		
+		/**
+		 * Returns the display string.
+		 * 
+		 * @return the display string which might contain type names or parameters
+		 */
+		public String getDisplayName();
+		
+		/**
+		 * Converts this object to the <code>TemplateObject</code>.
+		 * <p>
+		 * For example, if the instance corresponds a method,
+		 * this method would return the <code>TemplateObject</code> of 
+		 * the method return type.
+		 * 
+		 * @return the <code>TemplateObject</code> instance or <code>null</code>
+		 */
+		public TemplateObject toTemplateObject();
+	}
+	
+	///////////////////////////////////////////////////////////////////////////////////////
+	//
+	// Utility methods
+	//
+	///////////////////////////////////////////////////////////////////////////////////////
+	
+	/**
+	 * Get the simple classname from the full qualified classname.
+	 * 
+	 * @param name the full qualified classname
+	 * @return the simple classname
+	 */
+	private static String getSimpleName(String name){
+		String simpleName = ClickUtils.removeTypeParameter(name);
+		if(simpleName.indexOf('.')>=0){
+			simpleName = simpleName.substring(simpleName.lastIndexOf('.') + 1);
+		}
+		return simpleName;
+	}
+	
+	/**
+	 * Returns all public methods of the given type.
+	 * 
+	 * @param type the <code>IType</code> instance
+	 * @return all methods of the given type, not contains main method and constructor
+	 * @throws JavaModelException
+	 */
+	private static IMethod[] getAllMethods(IType type) throws JavaModelException {
+		ArrayList<IMethod> list = new ArrayList<IMethod>();
+		IMethod[] methods = type.getMethods();
+		for(int i=0;i<methods.length;i++){
+			if(!methods[i].isConstructor() && !methods[i].isMainMethod() && Flags.isPublic(methods[i].getFlags())){
+				list.add(methods[i]);
+			}
+		}
+		// search super class
+		ITypeHierarchy hierarchy = type.newSupertypeHierarchy(null);
+		extractMethods(hierarchy.getAllSuperclasses(type), list);
+		extractMethods(hierarchy.getSuperInterfaces(type), list);
+		
+		if(type.isInterface()){
+			extractMethods(new IType[]{
+					type.getJavaProject().findType("java.lang.Object")}, list);
+		}
+		return (IMethod[])list.toArray(new IMethod[list.size()]);
+	}
+	
+	private static void extractMethods(IType[] types, List<IMethod> methods) throws JavaModelException {
+		for(int i=0;i<types.length;i++){
+			IMethod[] superMethods = types[i].getMethods();
+			for(int j=0;j<superMethods.length;j++){
+				boolean flag = true;
+				if(!superMethods[j].isConstructor() && !superMethods[j].isMainMethod() && Flags.isPublic(superMethods[j].getFlags())){
+					for(int k=0;k<methods.size();k++){
+						IMethod method = (IMethod)methods.get(k);
+						if(equalsMethods(method, superMethods[j])){
+							flag = false;
+							break;
+						}
+					}
+					if(flag){
+						methods.add(superMethods[j]);
+					}
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Tests whether given methods are same.
+	 * 
+	 * @param method1 the <code>IMethod</code>
+	 * @param method2 the <code>IMethod</code>
+	 * @return <code>true</code> if given methods are same: <code>false</code> otherwise 
+	 */
+	private static boolean equalsMethods(IMethod method1, IMethod method2){
+		if(method1.getElementName().equals(method2.getElementName())){
+			String[] params1 = method1.getParameterTypes();
+			String[] params2 = method2.getParameterTypes();
+			if(params1.length==params2.length){
+				for(int i=0;i<params1.length;i++){
+					if(!params1[i].equals(params2[i])){
+						return false;
+					}
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/actions/ElementAppendAction.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/actions/ElementAppendAction.java
new file mode 100644
index 0000000..58688ef
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/actions/ElementAppendAction.java
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.actions;
+
+
+import org.apache.click.eclipse.ui.editor.forms.AbstractFormEditor;
+import org.eclipse.jface.action.Action;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+import org.w3c.dom.Element;
+
+/**
+ * <code>IAction</code> which appends the <code>IDOMElement</code>
+ * to the specified element.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ElementAppendAction extends Action {
+	
+	private IDOMElement parentElement;
+	private IDOMElement refElement;
+	private String newElement;
+	private AbstractFormEditor editor;
+	
+	public ElementAppendAction(String name, IDOMElement parentElement, 
+			IDOMElement refElement, AbstractFormEditor editor){
+		
+		super(name);
+		this.parentElement = parentElement;
+		this.refElement = refElement;
+		this.newElement = name;
+		this.editor = editor;
+	}
+	
+	public void run(){
+		Element element = parentElement.getOwnerDocument().createElement(newElement);
+		
+		if(refElement!=null){
+			parentElement.insertBefore(element, refElement);
+		} else {
+			parentElement.appendChild(element);
+		}
+		
+		TreeViewer viewer = (TreeViewer)editor.getAdapter(TreeViewer.class);
+		if(viewer!=null){
+			viewer.setSelection(new StructuredSelection(element));
+			viewer.refresh();
+		}
+		
+		editor.updateMenu();
+	}
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/actions/ElementRemoveAction.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/actions/ElementRemoveAction.java
new file mode 100644
index 0000000..be53a15
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/actions/ElementRemoveAction.java
@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.actions;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.eclipse.jface.action.Action;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ * <code>IAction</code> which removes the <code>IDOMElement</code> 
+ * from the parent element.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ElementRemoveAction extends Action{
+	
+	private IDOMElement element;
+	
+	public ElementRemoveAction(){
+		super(ClickPlugin.getString("action.delete"));
+	}
+	
+	public void setElement(IDOMElement element){
+		this.element = element;
+	}
+	
+	public void run(){
+		element.getParentNode().removeChild(element);
+	}
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/AttributeEditorUtils.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/AttributeEditorUtils.java
new file mode 100644
index 0000000..e64fc3a
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/AttributeEditorUtils.java
@@ -0,0 +1,271 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.attrs;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.ui.fieldassist.FieldAssistUtils;
+import org.apache.click.eclipse.ui.fieldassist.TypeNameContentProposalProvider;
+import org.apache.click.eclipse.ui.wizard.NewClassWizard;
+import org.apache.click.eclipse.ui.wizard.NewClickPageWizard;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.search.SearchEngine;
+import org.eclipse.jdt.ui.IJavaElementSearchConstants;
+import org.eclipse.jdt.ui.JavaUI;
+import org.eclipse.jface.dialogs.ProgressMonitorDialog;
+import org.eclipse.jface.fieldassist.TextContentAdapter;
+import org.eclipse.jface.fieldassist.TextControlCreator;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.jface.wizard.WizardDialog;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.dialogs.SelectionDialog;
+import org.eclipse.ui.fieldassist.ContentAssistField;
+import org.eclipse.ui.forms.events.HyperlinkAdapter;
+import org.eclipse.ui.forms.events.HyperlinkEvent;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.ui.forms.widgets.Hyperlink;
+import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+import org.w3c.dom.Element;
+
+/**
+ * Provides utility methods for attribute editors.
+ *
+ * @author Naoki Takezoe
+ */
+public class AttributeEditorUtils {
+
+	public static Control[] createLinkText(FormToolkit toolkit, Composite parent,
+			final IDOMElement element, String label, final String attrName){
+
+		Hyperlink link = toolkit.createHyperlink(parent, label, SWT.NULL);
+
+		Composite composite = FieldAssistUtils.createNullDecoratedPanel(parent, true);
+		final Text text = toolkit.createText(composite, "", SWT.BORDER);
+
+		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		text.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+
+		if(element!=null){
+			String initialValue = element.getAttribute(attrName);
+			if(initialValue!=null){
+				text.setText(initialValue);
+			}
+		}
+		return new Control[]{link, text};
+
+	}
+
+	/**
+	 * Creates the {@link Text} field editor.
+	 *
+	 * @param toolkit the <code>FormToolkit</code> instance
+	 * @param parent the parent composite
+	 * @param element the target element
+	 * @param label the field label
+	 * @param attrName the target attribute name
+	 */
+	public static Text createText(FormToolkit toolkit, Composite parent,
+			final IDOMElement element, String label, final String attrName){
+
+		toolkit.createLabel(parent, label);
+
+		Composite composite = FieldAssistUtils.createNullDecoratedPanel(parent, true);
+		final Text text = toolkit.createText(composite, "", SWT.BORDER);
+
+		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		text.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+
+		if(element!=null){
+			String initialValue = element.getAttribute(attrName);
+			if(initialValue!=null){
+				text.setText(initialValue);
+			}
+		}
+		return text;
+	}
+
+	/**
+	 * Creates the {@Combo} field editor.
+	 *
+	 * @param toolkit the <code>FormToolkit</code>
+	 * @param parent the parent composite
+	 * @param element the target element
+	 * @param label the field label
+	 * @param attrName the target attribute name
+	 * @param values proposals of the combobox
+	 */
+	public static Combo createCombo(FormToolkit toolkit, Composite parent,
+			final IDOMElement element, String label, final String attrName, String[] values){
+
+		toolkit.createLabel(parent, label);
+
+		Composite composite = FieldAssistUtils.createNullDecoratedPanel(parent, true);
+		final Combo combo = new Combo(composite, SWT.READ_ONLY);
+
+		for(int i=0;i<values.length;i++){
+			combo.add(values[i]);
+		}
+		if(element!=null){
+			String initialValue = element.getAttribute(attrName);
+			if(initialValue!=null){
+				combo.setText(initialValue);
+			}
+		}
+
+		return combo;
+	}
+
+	/**
+	 * Creates the classname field editor.
+	 *
+	 * @param project the <code>IJavaProject</code> instance
+	 * @param toolkit the <code>FormToolkit</code> instance
+	 * @param parent the parent composite
+	 * @param element the target element
+	 * @param attrName the target attribute name
+	 * @param superClass the super class
+	 * @param textFileName null or the text control for the HTML filename
+	 */
+	public static Text createClassText(final IJavaProject project,
+			FormToolkit toolkit, final Composite parent,
+			final IDOMElement element, String label, final String attrName,
+			final String superClass, final Text textFileName){
+
+		final Hyperlink link = toolkit.createHyperlink(parent, label, SWT.NULL);
+		link.addHyperlinkListener(new HyperlinkAdapter(){
+			public void linkActivated(HyperlinkEvent e){
+				try {
+					Control[] controls = parent.getChildren();
+					Text text = null;
+					for(int i=0;i<controls.length;i++){
+						if(i>0 && controls[i-1]==link && controls[i] instanceof Composite){
+							Composite composite = (Composite)controls[i];
+							text = (Text)((Composite)composite.getChildren()[0]).getChildren()[0];
+						}
+					}
+					if(text!=null && !text.getText().equals("")){
+						String className = text.getText();
+						if(superClass!=null && superClass==ClickPlugin.CLICK_PAGE_CLASS){
+							String packageName = ((Element)element.getParentNode()).getAttribute(ClickPlugin.ATTR_PACKAGE);
+							if(packageName!=null && packageName.length()!=0){
+								className = packageName + "." + className;
+							}
+						}
+						IFile file = (IFile)ClickUtils.getResource(element.getStructuredDocument());
+						IJavaProject project = JavaCore.create(file.getProject());
+						IType type = project.findType(className);
+						if(type!=null){
+							JavaUI.revealInEditor(JavaUI.openInEditor(type), (IJavaElement)type);
+						} else {
+							if(superClass!=null && superClass==ClickPlugin.CLICK_PAGE_CLASS){
+								// Opens the new page creation wizard
+								NewClickPageWizard wizard = new NewClickPageWizard();
+								wizard.init(PlatformUI.getWorkbench(), new StructuredSelection(project));
+								wizard.setInitialClassName(className);
+								if(textFileName!=null){
+									wizard.setInitialPageName(textFileName.getText());
+								}
+								WizardDialog dialog = new WizardDialog(text.getShell(), wizard);
+								dialog.open();
+							} else {
+								// Opens the new java class creation wizard
+								NewClassWizard wizard = new NewClassWizard();
+								wizard.init(PlatformUI.getWorkbench(), new StructuredSelection(project));
+								if(superClass!=null){
+									if(superClass == ClickPlugin.CLICK_CONTROL_IF || superClass.endsWith("Service")){
+										wizard.addInterface(superClass);
+									} else {
+										wizard.setSuperClass(superClass);
+									}
+								}
+								wizard.setClassName(className);
+								WizardDialog dialog = new WizardDialog(text.getShell(), wizard);
+								dialog.open();
+							}
+						}
+					}
+				} catch(Exception ex){
+					ClickPlugin.log(ex);
+				}
+			}
+		});
+
+
+		Composite composite = toolkit.createComposite(parent);
+		composite.setLayout(FieldAssistUtils.createGridLayout());
+		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+
+		ContentAssistField field = new ContentAssistField(composite, SWT.BORDER,
+				new TextControlCreator(), new TextContentAdapter(),
+				new TypeNameContentProposalProvider(project),
+				ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS,
+				new char[0]);
+
+		final Text text = (Text)field.getControl();
+		field.getLayoutControl().setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		field.getLayoutControl().setBackground(Display.getDefault().getSystemColor(SWT.COLOR_WHITE));
+
+		if(element!=null){
+			String initialValue = element.getAttribute(attrName);
+			if(initialValue!=null){
+				text.setText(initialValue);
+			}
+		}
+
+		Button button = toolkit.createButton(composite, ClickPlugin.getString("action.browse"), SWT.PUSH);
+		button.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				Shell shell = text.getShell();
+				try {
+					SelectionDialog dialog = JavaUI.createTypeDialog(
+							shell,new ProgressMonitorDialog(shell),
+							SearchEngine.createJavaSearchScope(new IJavaElement[]{project}),
+							IJavaElementSearchConstants.CONSIDER_CLASSES,false);
+
+					if(dialog.open()==SelectionDialog.OK){
+						Object[] result = dialog.getResult();
+						text.setText(((IType)result[0]).getFullyQualifiedName());
+					}
+				} catch(Exception ex){
+					ClickPlugin.log(ex);
+				}
+			}
+		});
+
+		return text;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ControlAttributeEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ControlAttributeEditor.java
new file mode 100644
index 0000000..54ff812
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ControlAttributeEditor.java
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.attrs;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ * The implementation of <code>IElementEditor</code> for &lt;control&gt;.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ControlAttributeEditor implements IAttributeEditor {
+	
+	public Composite createForm(FormToolkit toolkit, Composite parent, final IDOMElement element) {
+		final Composite composite = toolkit.createComposite(parent);
+		composite.setLayout(ClickUtils.createGridLayout(2));
+		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		
+		IFile file = (IFile)ClickUtils.getResource(element.getStructuredDocument());
+		IJavaProject project = JavaCore.create(file.getProject());
+		
+		final Text text = AttributeEditorUtils.createClassText(project, toolkit, composite, element, 
+				ClickPlugin.getString("editor.clickXML.controls.class"),
+				ClickPlugin.ATTR_CLASSNAME, ClickPlugin.CLICK_CONTROL_IF, null);
+		text.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(text.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_CLASSNAME);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_CLASSNAME, text.getText());
+				}
+			}
+		});
+		
+		return composite;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ControlSetAttributeEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ControlSetAttributeEditor.java
new file mode 100644
index 0000000..9928795
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ControlSetAttributeEditor.java
@@ -0,0 +1,34 @@
+package org.apache.click.eclipse.ui.editor.attrs;
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+public class ControlSetAttributeEditor implements IAttributeEditor {
+	
+	public Composite createForm(FormToolkit toolkit, Composite parent, final IDOMElement element) {
+		final Composite composite = toolkit.createComposite(parent);
+		composite.setLayout(ClickUtils.createGridLayout(2));
+		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		
+		final Text text = AttributeEditorUtils.createText(toolkit, composite, element, 
+				ClickPlugin.getString("editor.clickXML.controls.name"), ClickPlugin.ATTR_NAME);
+		text.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(text.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_NAME);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_NAME, text.getText());
+				}
+			}
+		});
+		
+		return composite;
+	}
+}
\ No newline at end of file
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ExcludesAttributeEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ExcludesAttributeEditor.java
new file mode 100644
index 0000000..ba1bef6
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ExcludesAttributeEditor.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.attrs;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class ExcludesAttributeEditor implements IAttributeEditor {
+
+	public Composite createForm(FormToolkit toolkit, Composite parent, final IDOMElement element) {
+		Composite composite = toolkit.createComposite(parent);
+		composite.setLayout(ClickUtils.createGridLayout(2));
+		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		
+		final Text textName = AttributeEditorUtils.createText(
+				toolkit, composite, element, 
+				ClickPlugin.getString("editor.clickXML.pages.excludePattern"),
+				ClickPlugin.ATTR_PATTERN);
+		textName.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(textName.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_PATTERN);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_PATTERN, textName.getText());
+				}
+			}
+		});
+		
+		return composite;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/HeaderAttributeEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/HeaderAttributeEditor.java
new file mode 100644
index 0000000..027688b
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/HeaderAttributeEditor.java
@@ -0,0 +1,93 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.attrs;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ * The implementation of <code>IElementEditor</code> for &lt;header&gt;.
+ * 
+ * @author Naoki Takezoe
+ */
+public class HeaderAttributeEditor implements IAttributeEditor {
+	
+	public Composite createForm(FormToolkit toolkit, Composite parent, final IDOMElement element) {
+		Composite composite = toolkit.createComposite(parent);
+		composite.setLayout(ClickUtils.createGridLayout(2));
+		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		
+		final Text textName = AttributeEditorUtils.createText(
+				toolkit, composite, element, 
+				ClickPlugin.getString("editor.clickXML.headers.name"),
+				ClickPlugin.ATTR_NAME);
+		textName.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(textName.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_NAME);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_NAME, textName.getText());
+				}
+			}
+		});
+		
+		final Text textValue = AttributeEditorUtils.createText(
+				toolkit, composite, element, 
+				ClickPlugin.getString("editor.clickXML.headers.value"), 
+				ClickPlugin.ATTR_VALUE);
+		textValue.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(textValue.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_VALUE);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_VALUE, textValue.getText());
+				}
+			}
+		});
+		
+		final Combo combo = AttributeEditorUtils.createCombo(
+				toolkit, composite, element, 
+				ClickPlugin.getString("editor.clickXML.headers.type"), 
+				ClickPlugin.ATTR_TYPE, 
+				ClickUtils.createComboValues(ClickPlugin.HEADER_TYPE_VALUES));
+		combo.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				if(combo.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_TYPE);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_TYPE, combo.getText());
+				}
+			}
+		});
+		
+		return composite;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/IAttributeEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/IAttributeEditor.java
new file mode 100644
index 0000000..cacdf06
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/IAttributeEditor.java
@@ -0,0 +1,45 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.attrs;
+
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ * The interface of element editors in the {@link net.sf.clickide.ui.editor.ClickTreeEditor}.
+ * <p>
+ * Subclasses would provide the form editor to edit the element attributes.
+ * 
+ * @author Naoki Takezoe
+ * @see net.sf.clickide.ui.editor.ClickTreeEditor
+ */
+public interface IAttributeEditor {
+	
+	/**
+	 * Creates the form for the element editing.
+	 * 
+	 * @param toolkit FormToolkit
+	 * @param parent the parent composite
+	 * @param element the target element
+	 * @return the form composite
+	 */
+	public Composite createForm(FormToolkit toolkit, Composite parent, IDOMElement element);
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/PageAttributeEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/PageAttributeEditor.java
new file mode 100644
index 0000000..73e2d23
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/PageAttributeEditor.java
@@ -0,0 +1,119 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.attrs;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.ui.wizard.NewClickPageWizard;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.Path;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jface.viewers.StructuredSelection;
+import org.eclipse.jface.wizard.WizardDialog;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.forms.events.HyperlinkAdapter;
+import org.eclipse.ui.forms.events.HyperlinkEvent;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.ui.forms.widgets.Hyperlink;
+import org.eclipse.ui.ide.IDE;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ * The implementation of <code>IElementEditor</code> for &lt;page&gt;.
+ * 
+ * @author Naoki Takezoe
+ */
+public class PageAttributeEditor implements IAttributeEditor {
+	
+	public Composite createForm(FormToolkit toolkit, Composite parent, final IDOMElement element) {
+		Composite composite = toolkit.createComposite(parent);
+		composite.setLayout(ClickUtils.createGridLayout(2));
+		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		
+		Control[] controls = AttributeEditorUtils.createLinkText(
+				toolkit, composite, element, 
+				ClickPlugin.getString("editor.clickXML.pages.path"),
+				ClickPlugin.ATTR_PATH);
+		final Hyperlink linkPath = (Hyperlink)controls[0];
+		final Text textPath = (Text)controls[1];
+		textPath.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(textPath.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_PATH);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_PATH, textPath.getText());
+				}
+			}
+		});
+		
+		IFile file = (IFile)ClickUtils.getResource(element.getStructuredDocument());
+		IJavaProject project = JavaCore.create(file.getProject());
+		
+		final Text textClass = AttributeEditorUtils.createClassText(
+				project, toolkit, composite, element, 
+				ClickPlugin.getString("editor.clickXML.pages.class"), 
+				ClickPlugin.ATTR_CLASSNAME,
+				ClickPlugin.CLICK_PAGE_CLASS, textPath);
+		textClass.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(textClass.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_CLASSNAME);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_CLASSNAME, textClass.getText());
+				}
+			}
+		});
+		
+		linkPath.addHyperlinkListener(new HyperlinkAdapter(){
+			public void linkActivated(HyperlinkEvent e){
+				IFile file = (IFile)ClickUtils.getResource(element.getStructuredDocument());
+				IProject project = file.getProject();
+				String root = ClickUtils.getWebAppRootFolder(project);
+				try {
+					IFile targetFile = project.getFile(new Path(root).append(textPath.getText()));
+					if(targetFile.exists()){
+						IDE.openEditor(ClickUtils.getActivePage(), targetFile);
+						return;
+					}
+				} catch(Exception ex){
+				}
+				
+				NewClickPageWizard wizard = new NewClickPageWizard();
+				wizard.init(PlatformUI.getWorkbench(), new StructuredSelection(project));
+				wizard.setInitialPageName(textPath.getText());
+				wizard.setInitialClassName(textClass.getText());
+				WizardDialog dialog = new WizardDialog(textPath.getShell(), wizard);
+				dialog.open();
+			}
+		});
+		
+		
+		return composite;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/PagesAttributeEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/PagesAttributeEditor.java
new file mode 100644
index 0000000..52b05e7
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/PagesAttributeEditor.java
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.attrs;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ * The implementation of <code>IElementEditor</code> for &lt;pages&gt;.
+ * 
+ * @author Naoki Takezoe
+ */
+public class PagesAttributeEditor implements IAttributeEditor {
+	
+	public Composite createForm(FormToolkit toolkit, Composite parent, final IDOMElement element) {
+		Composite composite = toolkit.createComposite(parent);
+		composite.setLayout(ClickUtils.createGridLayout(2));
+		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		
+		final Text text = AttributeEditorUtils.createText(
+				toolkit, composite, element,
+				ClickPlugin.getString("editor.clickXML.pages.package"), 
+				ClickPlugin.ATTR_PACKAGE);
+		text.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(text.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_PACKAGE);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_PACKAGE, text.getText());
+				}
+			}
+		});
+		
+		final Combo autoMapping = AttributeEditorUtils.createCombo(
+				toolkit, composite, element, 
+				ClickPlugin.getString("editor.clickXML.pages.autoMapping"), 
+				ClickPlugin.ATTR_AUTO_MAPPING,
+				ClickUtils.createComboValues(ClickPlugin.BOOLEAN_VALUES));
+		autoMapping.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				if(autoMapping.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_AUTO_MAPPING);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_AUTO_MAPPING, autoMapping.getText());
+				}
+			}
+		});
+		
+		final Combo autoBinding = AttributeEditorUtils.createCombo(
+				toolkit, composite, element, 
+				ClickPlugin.getString("editor.clickXML.pages.autoBinding"), 
+				ClickPlugin.ATTR_AUTO_BINDING,
+				ClickUtils.createComboValues(ClickPlugin.AUTO_BINDING_VALUES));
+		autoBinding.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				if(autoBinding.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_AUTO_BINDING);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_AUTO_BINDING, autoBinding.getText());
+				}
+			}
+		});
+		
+		return composite;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/PropertyAttributeEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/PropertyAttributeEditor.java
new file mode 100644
index 0000000..58dd71c
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/PropertyAttributeEditor.java
@@ -0,0 +1,75 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.attrs;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class PropertyAttributeEditor implements IAttributeEditor {
+
+	public Composite createForm(FormToolkit toolkit, Composite parent,
+			final IDOMElement element) {
+		Composite composite = toolkit.createComposite(parent);
+		composite.setLayout(ClickUtils.createGridLayout(2));
+		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		
+		final Text nameText = AttributeEditorUtils.createText(
+				toolkit, composite, element,
+				ClickPlugin.getString("editor.clickXML.property.name"), 
+				ClickPlugin.ATTR_NAME);
+		nameText.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(nameText.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_NAME);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_NAME, nameText.getText());
+				}
+			}
+		});
+		
+		final Text valueText = AttributeEditorUtils.createText(
+				toolkit, composite, element,
+				ClickPlugin.getString("editor.clickXML.property.value"), 
+				ClickPlugin.ATTR_VALUE);
+		valueText.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(valueText.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_VALUE);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_VALUE, valueText.getText());
+				}
+			}
+		});
+		
+		return composite;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ServiceClassNameAttributeEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ServiceClassNameAttributeEditor.java
new file mode 100644
index 0000000..e84fd0b
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/attrs/ServiceClassNameAttributeEditor.java
@@ -0,0 +1,75 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.attrs;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ *
+ * @author Naoki Takezoe
+ * @since 2.1.0
+ */
+public class ServiceClassNameAttributeEditor implements IAttributeEditor {
+
+	private String superClassName;
+
+	public ServiceClassNameAttributeEditor(String superClassName){
+		this.superClassName = superClassName;
+	}
+
+	public Composite createForm(FormToolkit toolkit, Composite parent,
+			final IDOMElement element) {
+		Composite composite = toolkit.createComposite(parent);
+		composite.setLayout(ClickUtils.createGridLayout(2));
+		composite.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+
+		IFile file = (IFile)ClickUtils.getResource(element.getStructuredDocument());
+		IJavaProject project = JavaCore.create(file.getProject());
+
+		final Text textClass = AttributeEditorUtils.createClassText(
+				project, toolkit, composite, element,
+				ClickPlugin.getString("editor.clickXML.pages.class"),
+				ClickPlugin.ATTR_CLASSNAME,
+				superClassName, null);
+		textClass.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(textClass.getText().equals("")){
+					element.removeAttribute(ClickPlugin.ATTR_CLASSNAME);
+				} else {
+					element.setAttribute(ClickPlugin.ATTR_CLASSNAME, textClass.getText());
+				}
+			}
+		});
+
+		return composite;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/AbstractFormEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/AbstractFormEditor.java
new file mode 100644
index 0000000..e28891c
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/AbstractFormEditor.java
@@ -0,0 +1,84 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.forms;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.ui.IEditorInput;
+import org.eclipse.ui.IEditorSite;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.forms.widgets.Form;
+import org.eclipse.ui.forms.widgets.FormToolkit;
+import org.eclipse.ui.part.EditorPart;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+
+/**
+ * The base class for form editors.
+ * 
+ * @author Naoki Takezoe
+ */
+public abstract class AbstractFormEditor extends EditorPart {
+
+	protected FormToolkit toolkit;
+	protected Form form;
+	
+	public void doSave(IProgressMonitor monitor) {
+	}
+
+	public void doSaveAs() {
+	}
+
+	public void init(IEditorSite site, IEditorInput input) throws PartInitException {
+		setSite(site);
+		setInput(input);
+	}
+
+	public boolean isDirty() {
+		return false;
+	}
+
+	public boolean isSaveAsAllowed() {
+		return false;
+	}
+
+	public void updateMenu(){
+	}
+	
+	public void createPartControl(Composite parent) {
+		toolkit = new FormToolkit(parent.getDisplay());
+		form = toolkit.createForm(parent);
+		form.setText(ClickPlugin.getString("editor.clickXML.title"));
+		form.getBody().setLayout(new GridLayout(1, false));
+		form.getBody().setLayoutData(new GridData(GridData.FILL_BOTH));
+		toolkit.decorateFormHeading(form);
+	}
+	
+	public abstract void initModel(IStructuredModel model);
+	
+	public abstract void modelUpdated(IStructuredModel model);
+	
+	public void setFocus() {
+		form.setFocus();
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/AbstractMasterDetailEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/AbstractMasterDetailEditor.java
new file mode 100644
index 0000000..e66f881
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/AbstractMasterDetailEditor.java
@@ -0,0 +1,182 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.forms;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ui.editor.actions.ElementRemoveAction;
+import org.apache.click.eclipse.ui.editor.attrs.IAttributeEditor;
+import org.eclipse.jface.action.MenuManager;
+import org.eclipse.jface.action.Separator;
+import org.eclipse.jface.viewers.ISelectionChangedListener;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.viewers.SelectionChangedEvent;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.custom.SashForm;
+import org.eclipse.swt.events.KeyAdapter;
+import org.eclipse.swt.events.KeyEvent;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.FillLayout;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Tree;
+import org.eclipse.ui.forms.widgets.Section;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+public abstract class AbstractMasterDetailEditor extends AbstractFormEditor {
+
+	protected SashForm sash;
+	protected TreeViewer viewer;
+	protected Composite currentEditor;
+	
+	protected MenuManager menu;
+	protected MenuManager newMenu;
+	protected ElementRemoveAction deleteAction = new ElementRemoveAction();
+	
+	protected abstract String[] getAcceptElementNames();
+	
+	protected abstract IAttributeEditor getAttributeEditor(String elementName);
+	
+	protected abstract void createMenu(IDOMElement element);
+	
+	public void initModel(IStructuredModel model) {
+		sash = new SashForm(form.getBody(), SWT.HORIZONTAL);
+		sash.setLayoutData(new GridData(GridData.FILL_BOTH));
+		sash.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_WHITE));
+		
+		final Composite left = toolkit.createComposite(sash);
+		left.setLayoutData(new GridData(GridData.FILL_BOTH));
+		left.setLayout(new FillLayout());
+		
+		Section headerSection = toolkit.createSection(left, Section.TITLE_BAR);
+		headerSection.setText(ClickPlugin.getString("editor.clickXML.outline"));
+		
+		Composite detailComposite = toolkit.createComposite(sash);
+		detailComposite.setLayoutData(new GridData(GridData.FILL_BOTH));
+		detailComposite.setLayout(new FillLayout());
+		
+		Section detailSection = toolkit.createSection(detailComposite, Section.TITLE_BAR);
+		detailSection.setText(ClickPlugin.getString("editor.clickXML.details"));
+		
+		final Composite right = toolkit.createComposite(detailSection);
+		right.setLayout(new FillLayout());
+		detailSection.setClient(right);
+		
+		Tree tree = toolkit.createTree(headerSection, SWT.NULL);
+		tree.setLayoutData(new GridData(GridData.FILL_BOTH));
+		headerSection.setClient(tree);
+		
+		List<String> acceptElements = new ArrayList<String>();
+		String[] acceptElementNames = getAcceptElementNames();
+		for(int i=0;i<acceptElementNames.length;i++){
+			acceptElements.add(acceptElementNames[i]);
+		}
+		
+		viewer = new TreeViewer(tree);
+		viewer.setContentProvider(new ClickTreeContentProvider(acceptElements));
+		viewer.setLabelProvider(new ClickTreeLabelProvider());
+		viewer.addSelectionChangedListener(new ISelectionChangedListener(){
+			public void selectionChanged(SelectionChangedEvent event){
+				if(currentEditor!=null){
+					currentEditor.dispose();
+				}
+				IStructuredSelection selection = (IStructuredSelection)event.getSelection();
+				Object obj = selection.getFirstElement();
+				if(obj != null){
+					if(obj instanceof IDOMElement){
+						IAttributeEditor editor = getAttributeEditor(((IDOMElement)obj).getNodeName());
+						if(editor != null){
+							currentEditor = editor.createForm(toolkit, right, (IDOMElement)obj);
+						}
+					}
+				}
+				right.layout();
+			}
+		});
+		
+		viewer.setInput(model);
+		viewer.expandAll();
+		
+		menu = new MenuManager();
+		newMenu = new MenuManager(ClickPlugin.getString("action.new"));
+		menu.add(newMenu);
+		menu.add(new Separator());
+		menu.add(deleteAction);
+		tree.setMenu(menu.createContextMenu(tree));
+		tree.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				updateMenu();
+			}
+		});
+		tree.addKeyListener(new KeyAdapter(){
+			public void keyReleased(KeyEvent e) {
+				if(e.keyCode == SWT.DEL && deleteAction.isEnabled()){
+					deleteAction.run();
+				}
+			}
+		});
+		
+		toolkit.paintBordersFor(left);
+	}
+	
+	public void updateMenu(){
+		newMenu.removeAll();
+		
+		IStructuredSelection selection = (IStructuredSelection)viewer.getSelection();
+		Object obj = selection.getFirstElement();
+		
+		if(obj instanceof IDOMElement){
+			IDOMElement element = (IDOMElement)obj;
+			
+			if(element.getNodeName().equals(ClickPlugin.TAG_CLICK_APP)){
+				deleteAction.setEnabled(false);
+			} else {
+				deleteAction.setEnabled(true);
+				deleteAction.setElement(element);
+			}
+			
+			createMenu(element);
+		}
+	}
+
+	public void modelUpdated(IStructuredModel model) {
+		viewer.setSelection(null);
+		viewer.refresh();
+	}
+	
+	public void setFocus() {
+		form.setFocus();
+	}
+	
+	@SuppressWarnings("unchecked")
+	public Object getAdapter(Class adapter) {
+		if(adapter.equals(TreeViewer.class)){
+			return this.viewer;
+		}
+		return super.getAdapter(adapter);
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickControlsEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickControlsEditor.java
new file mode 100644
index 0000000..6aaa0b8
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickControlsEditor.java
@@ -0,0 +1,63 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.forms;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.ui.editor.actions.ElementAppendAction;
+import org.apache.click.eclipse.ui.editor.attrs.ControlAttributeEditor;
+import org.apache.click.eclipse.ui.editor.attrs.ControlSetAttributeEditor;
+import org.apache.click.eclipse.ui.editor.attrs.IAttributeEditor;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickControlsEditor extends AbstractMasterDetailEditor {
+	
+	protected void createMenu(IDOMElement element){
+		if(element.getNodeName().equals(ClickPlugin.TAG_CLICK_APP) && 
+				ClickUtils.getElement(element, ClickPlugin.TAG_CONTROLS)==null){
+			newMenu.add(new ElementAppendAction(ClickPlugin.TAG_CONTROLS, element, null, this));
+		}
+		if(element.getNodeName().equals(ClickPlugin.TAG_CONTROLS)){
+			IDOMElement controlSet = ClickUtils.getElement(element, ClickPlugin.TAG_CONTROL_SET);
+			
+			newMenu.add(new ElementAppendAction(ClickPlugin.TAG_CONTROL, element, controlSet, this));
+			newMenu.add(new ElementAppendAction(ClickPlugin.TAG_CONTROL_SET, element, null, this));
+		}
+	}
+
+	protected String[] getAcceptElementNames() {
+		return new String[]{ClickPlugin.TAG_CONTROLS, ClickPlugin.TAG_CONTROL, ClickPlugin.TAG_CONTROL_SET};
+	}
+
+	protected IAttributeEditor getAttributeEditor(String elementName) {
+		if(elementName.equals(ClickPlugin.TAG_CONTROL)){
+			return new ControlAttributeEditor();
+			
+		} else if(elementName.equals(ClickPlugin.TAG_CONTROL_SET)){
+			return new ControlSetAttributeEditor();
+		}
+		return null;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickGeneralEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickGeneralEditor.java
new file mode 100644
index 0000000..1f68a4a
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickGeneralEditor.java
@@ -0,0 +1,209 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.forms;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.ui.editor.attrs.AttributeEditorUtils;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.forms.widgets.Section;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
+import org.w3c.dom.NodeList;
+
+/**
+ * The form editor to editing Click general informations.
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickGeneralEditor extends AbstractFormEditor {
+	
+	private Text textCharset;
+	private Text textLocale;
+	private Text textFormat;
+	private Combo comboMode;
+	
+	public void initModel(IStructuredModel model){
+		Section generic = toolkit.createSection(form.getBody(), Section.TITLE_BAR);
+		generic.setText(ClickPlugin.getString("editor.clickXML.general"));
+		generic.setLayoutData(ClickUtils.createGridData(2, GridData.FILL_HORIZONTAL));
+		
+		IDOMDocument doc = ((IDOMModel)model).getDocument();
+		NodeList nodes = doc.getElementsByTagName(ClickPlugin.TAG_CLICK_APP);
+		final IDOMElement clickApp = (IDOMElement)nodes.item(0);
+		IDOMElement format = ClickUtils.getElement(clickApp, ClickPlugin.TAG_FORMAT);
+		IDOMElement mode   = ClickUtils.getElement(clickApp, ClickPlugin.TAG_MODE);
+		
+		Composite compsote = toolkit.createComposite(generic);
+		compsote.setLayout(ClickUtils.createGridLayout(2));
+		compsote.setLayoutData(new GridData(GridData.FILL_BOTH));
+		generic.setClient(compsote);
+		
+		textCharset = AttributeEditorUtils.createText(
+				toolkit, compsote, clickApp, 
+				ClickPlugin.getString("editor.clickXML.general.charset"), 
+				ClickPlugin.ATTR_CHARSET);
+		textCharset.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(textCharset.getText().equals("")){
+					clickApp.removeAttribute(ClickPlugin.ATTR_CHARSET);
+				} else {
+					clickApp.setAttribute(ClickPlugin.ATTR_CHARSET, textCharset.getText());
+				}
+			}
+		});
+		
+		textLocale = AttributeEditorUtils.createText(
+				toolkit, compsote, clickApp,
+				ClickPlugin.getString("editor.clickXML.general.locale"), 
+				ClickPlugin.ATTR_LOCALE);
+		textLocale.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(textLocale.getText().equals("")){
+					clickApp.removeAttribute(ClickPlugin.ATTR_LOCALE);
+				} else {
+					clickApp.setAttribute(ClickPlugin.ATTR_LOCALE, textLocale.getText());
+				}
+			}
+		});
+		
+		IFile file = (IFile)ClickUtils.getResource(clickApp.getStructuredDocument());
+		IJavaProject project = JavaCore.create(file.getProject());
+		
+		textFormat = AttributeEditorUtils.createClassText(
+				project, toolkit, compsote, format, 
+				ClickPlugin.getString("editor.clickXML.general.format"), 
+				ClickPlugin.ATTR_CLASSNAME, null, null);
+		textFormat.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				IDOMElement format = ClickUtils.getElement(clickApp, ClickPlugin.TAG_FORMAT);
+				if(textFormat.getText().equals("")){
+					if(format!=null){
+						clickApp.removeChild(format);
+					}
+				} else {
+					if(format==null){
+						format = (IDOMElement)clickApp.getOwnerDocument().createElement(ClickPlugin.TAG_FORMAT);
+						IDOMElement[] elements = {
+								ClickUtils.getElement(clickApp, ClickPlugin.TAG_MODE),
+								ClickUtils.getElement(clickApp, ClickPlugin.TAG_CONTROLS)};
+						for(int i=0;i<elements.length;i++){
+							if(elements[i]!=null){
+								clickApp.insertBefore(format, elements[i]);
+								break;
+							}
+						}
+						if(ClickUtils.getElement(clickApp, ClickPlugin.TAG_FORMAT)==null){
+							clickApp.appendChild(format);
+						}
+					}
+					format.setAttribute(ClickPlugin.ATTR_CLASSNAME, textFormat.getText());
+				}
+			}
+		});
+		
+		comboMode = AttributeEditorUtils.createCombo(
+				toolkit, compsote, mode, 
+				ClickPlugin.getString("editor.clickXML.general.mode"), 
+				ClickPlugin.ATTR_VALUE, 
+				ClickUtils.createComboValues(ClickPlugin.MODE_VALUES));
+		comboMode.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				IDOMElement mode = ClickUtils.getElement(clickApp, ClickPlugin.TAG_MODE);
+				if(comboMode.getText().equals("")){
+					if(mode!=null){
+						mode.removeAttribute(ClickPlugin.ATTR_VALUE);
+						if(mode.getAttributes().getLength()==0){
+							clickApp.removeChild(mode);
+						}
+					}
+				} else {
+					if(mode==null){
+						mode = (IDOMElement)clickApp.getOwnerDocument().createElement(ClickPlugin.TAG_MODE);
+						IDOMElement control = ClickUtils.getElement(clickApp, ClickPlugin.TAG_CONTROLS);
+						if(control!=null){
+							clickApp.insertBefore(mode, control);
+						} else {
+							clickApp.appendChild(mode);
+						}
+					}
+					mode.setAttribute(ClickPlugin.ATTR_VALUE, comboMode.getText());
+				}
+			}
+		});
+		
+		form.getBody().layout();
+	}
+
+	public void modelUpdated(IStructuredModel model){
+		IDOMDocument doc = ((IDOMModel)model).getDocument();
+		NodeList nodes = doc.getElementsByTagName(ClickPlugin.TAG_CLICK_APP);
+		IDOMElement clickApp = (IDOMElement)nodes.item(0);
+		IDOMElement format = ClickUtils.getElement(clickApp, ClickPlugin.TAG_FORMAT);
+		IDOMElement mode   = ClickUtils.getElement(clickApp, ClickPlugin.TAG_MODE);
+
+		updateText(textCharset, clickApp, ClickPlugin.ATTR_CHARSET);
+		updateText(textFormat, format, ClickPlugin.ATTR_CLASSNAME);
+		updateCombo(comboMode, mode, ClickPlugin.ATTR_VALUE);
+//		updateCombo(comboLogTo, mode, ClickPlugin.ATTR_LOGTO);
+	}
+	
+	private void updateText(Text text, IDOMElement element, String attrName){
+		if(element!=null && element.getAttribute(attrName)!=null){
+			if(!text.getText().equals(element.getAttribute(attrName))){
+				text.setText(element.getAttribute(attrName));
+			}
+		} else {
+			if(!text.getText().equals("")){
+				text.setText("");
+			}
+		}
+	}
+	
+	private void updateCombo(Combo combo, IDOMElement element, String attrName){
+		if(element!=null && element.getAttribute(attrName)!=null){
+			if(!combo.getText().equals(element.getAttribute(attrName))){
+				combo.setText(element.getAttribute(attrName));
+			}
+		} else {
+			if(!combo.getText().equals("")){
+				combo.setText("");
+			}
+		}
+	}
+	
+	public void setFocus() {
+		form.setFocus();
+	}
+	
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickHeadersEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickHeadersEditor.java
new file mode 100644
index 0000000..da6a3be
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickHeadersEditor.java
@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.forms;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.ui.editor.actions.ElementAppendAction;
+import org.apache.click.eclipse.ui.editor.attrs.HeaderAttributeEditor;
+import org.apache.click.eclipse.ui.editor.attrs.IAttributeEditor;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickHeadersEditor extends AbstractMasterDetailEditor {
+	
+	protected void createMenu(IDOMElement element){
+		if(element.getNodeName().equals(ClickPlugin.TAG_CLICK_APP) && 
+				ClickUtils.getElement(element, ClickPlugin.TAG_HEADERS)==null){
+			IDOMElement[] elements = {
+					ClickUtils.getElement(element, ClickPlugin.TAG_FORMAT),
+					ClickUtils.getElement(element, ClickPlugin.TAG_MODE),
+					ClickUtils.getElement(element, ClickPlugin.TAG_CONTROLS)};
+			for(int i=0;i<elements.length;i++){
+				if(elements[i]!=null){
+					newMenu.add(new ElementAppendAction(ClickPlugin.TAG_HEADERS, element, elements[i], this));
+					break;
+				}
+			}
+			if(newMenu.getItems().length==0){
+				newMenu.add(new ElementAppendAction(ClickPlugin.TAG_HEADERS, element, null, this));
+			}
+		}
+		if(element.getNodeName().equals(ClickPlugin.TAG_HEADERS)){
+			newMenu.add(new ElementAppendAction(ClickPlugin.TAG_HEADER, element, null, this));
+		}
+	}
+
+	protected String[] getAcceptElementNames() {
+		return new String[]{ClickPlugin.TAG_HEADERS, ClickPlugin.TAG_HEADER};
+	}
+
+	protected IAttributeEditor getAttributeEditor(String elementName) {
+		if(elementName.equals(ClickPlugin.TAG_HEADER)){
+			return new HeaderAttributeEditor();
+		}
+		return null;
+	}
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickPagesEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickPagesEditor.java
new file mode 100644
index 0000000..6604354
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickPagesEditor.java
@@ -0,0 +1,81 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.forms;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.ui.editor.actions.ElementAppendAction;
+import org.apache.click.eclipse.ui.editor.attrs.ExcludesAttributeEditor;
+import org.apache.click.eclipse.ui.editor.attrs.IAttributeEditor;
+import org.apache.click.eclipse.ui.editor.attrs.PageAttributeEditor;
+import org.apache.click.eclipse.ui.editor.attrs.PagesAttributeEditor;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickPagesEditor extends AbstractMasterDetailEditor {
+
+	protected void createMenu(IDOMElement element){
+		if(element.getNodeName().equals(ClickPlugin.TAG_CLICK_APP) && 
+				ClickUtils.getElement(element, ClickPlugin.TAG_PAGES)==null){
+			IDOMElement[] elements = {
+					ClickUtils.getElement(element, ClickPlugin.TAG_HEADERS),
+					ClickUtils.getElement(element, ClickPlugin.TAG_FORMAT),
+					ClickUtils.getElement(element, ClickPlugin.TAG_MODE),
+					ClickUtils.getElement(element, ClickPlugin.TAG_CONTROLS)};
+			for(int i=0;i<elements.length;i++){
+				if(elements[i]!=null){
+					newMenu.add(new ElementAppendAction(
+							ClickPlugin.TAG_PAGES, element, elements[i], this));
+					break;
+				}
+			}
+			if(newMenu.getItems().length==0){
+				newMenu.add(new ElementAppendAction(
+						ClickPlugin.TAG_PAGES, element, null, this));
+			}
+		}
+		if(element.getNodeName().equals(ClickPlugin.TAG_PAGES)){
+			newMenu.add(new ElementAppendAction(ClickPlugin.TAG_PAGE, element, null, this));
+			newMenu.add(new ElementAppendAction(ClickPlugin.TAG_EXCLUDES, element, null, this));
+		}
+	}
+
+	protected String[] getAcceptElementNames() {
+		return new String[]{ClickPlugin.TAG_PAGES, 
+				ClickPlugin.TAG_PAGE, ClickPlugin.TAG_EXCLUDES};
+	}
+
+	protected IAttributeEditor getAttributeEditor(String elementName) {
+		if(elementName.equals(ClickPlugin.TAG_PAGE)){
+			return new PageAttributeEditor();
+		}
+		if(elementName.equals(ClickPlugin.TAG_EXCLUDES)){
+			return new ExcludesAttributeEditor();
+		}
+		if(elementName.equals(ClickPlugin.TAG_PAGES)){
+			return new PagesAttributeEditor();
+		}
+		return null;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickServiceEditor.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickServiceEditor.java
new file mode 100644
index 0000000..c4ffc84
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickServiceEditor.java
@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.forms;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.ui.editor.actions.ElementAppendAction;
+import org.apache.click.eclipse.ui.editor.attrs.IAttributeEditor;
+import org.apache.click.eclipse.ui.editor.attrs.PropertyAttributeEditor;
+import org.apache.click.eclipse.ui.editor.attrs.ServiceClassNameAttributeEditor;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+
+/**
+ *
+ * @author Naoki Takezoe
+ * @since 2.1.0
+ */
+public class ClickServiceEditor extends AbstractMasterDetailEditor {
+
+	protected void createMenu(IDOMElement element) {
+		if(element.getNodeName().equals(ClickPlugin.TAG_CLICK_APP)){
+			if(ClickUtils.getElement(element, ClickPlugin.TAG_FILE_UPLOAD_SERVICE)==null){
+				newMenu.add(new ElementAppendAction(ClickPlugin.TAG_FILE_UPLOAD_SERVICE, element, null, this));
+			}
+			if(ClickUtils.getElement(element, ClickPlugin.TAG_LOG_SERVICE)==null){
+				newMenu.add(new ElementAppendAction(ClickPlugin.TAG_LOG_SERVICE, element, null, this));
+			}
+			if(ClickUtils.getElement(element, ClickPlugin.TAG_TEMPLATE_SERVICE)==null){
+				newMenu.add(new ElementAppendAction(ClickPlugin.TAG_TEMPLATE_SERVICE, element, null, this));
+			}
+			if(ClickUtils.getElement(element, ClickPlugin.TAG_RESOURCE_SERVICE)==null){
+				newMenu.add(new ElementAppendAction(ClickPlugin.TAG_RESOURCE_SERVICE, element, null, this));
+			}
+		}
+		if(element.getNodeName().equals(ClickPlugin.TAG_FILE_UPLOAD_SERVICE) ||
+				element.getNodeName().equals(ClickPlugin.TAG_LOG_SERVICE) ||
+				element.getNodeName().equals(ClickPlugin.TAG_TEMPLATE_SERVICE) ||
+				element.getNodeName().equals(ClickPlugin.TAG_RESOURCE_SERVICE)){
+			newMenu.add(new ElementAppendAction(ClickPlugin.TAG_PROPERTY, element, null, this));
+		}
+	}
+
+	protected String[] getAcceptElementNames() {
+		return new String[]{ClickPlugin.TAG_FILE_UPLOAD_SERVICE, ClickPlugin.TAG_LOG_SERVICE, 
+				ClickPlugin.TAG_TEMPLATE_SERVICE, ClickPlugin.TAG_RESOURCE_SERVICE, 
+				ClickPlugin.TAG_PROPERTY};
+	}
+
+	protected IAttributeEditor getAttributeEditor(String elementName) {
+		if(elementName.equals(ClickPlugin.TAG_FILE_UPLOAD_SERVICE)){
+			return new ServiceClassNameAttributeEditor("org.apache.click.service.FileUploadService");
+		}
+		if(elementName.equals(ClickPlugin.TAG_LOG_SERVICE)){
+			return new ServiceClassNameAttributeEditor("org.apache.click.service.LogService");
+		}
+		if(elementName.equals(ClickPlugin.TAG_TEMPLATE_SERVICE)){
+			return new ServiceClassNameAttributeEditor("org.apache.click.service.TemplateService");
+		}
+		if(elementName.equals(ClickPlugin.TAG_RESOURCE_SERVICE)){
+			return new ServiceClassNameAttributeEditor("org.apache.click.service.ResourceService");
+		}
+		if(elementName.equals(ClickPlugin.TAG_PROPERTY)){
+			return new PropertyAttributeEditor();
+		}
+		return null;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickTreeContentProvider.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickTreeContentProvider.java
new file mode 100644
index 0000000..d295b1a
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickTreeContentProvider.java
@@ -0,0 +1,62 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.forms;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+import org.eclipse.wst.xml.ui.internal.contentoutline.JFaceNodeContentProvider;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class ClickTreeContentProvider extends JFaceNodeContentProvider {
+	
+	private List<String> accept;
+	
+	public ClickTreeContentProvider(List<String> accept){
+		this.accept = accept;
+	}
+	
+	public Object[] getChildren(Object object) {
+		List<Object> result = new ArrayList<Object>();
+		Object[] children =  super.getChildren(object);
+		for(int i=0;i<children.length;i++){
+			if(children[i] instanceof IDOMElement){
+				String name = ((IDOMElement)children[i]).getNodeName();
+				if(this.accept.contains(name)){
+					result.add(children[i]);
+				}
+			}
+		}
+		return result.toArray();
+	}
+
+	public Object[] getElements(Object object) {
+		Object[] obj = super.getElements(object);
+		for(int i=0;i<obj.length;i++){
+			if(obj[i] instanceof IDOMElement){
+				return new Object[]{obj[i]};
+			}
+		}
+		return null;
+	}
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickTreeLabelProvider.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickTreeLabelProvider.java
new file mode 100644
index 0000000..ed73f14
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/editor/forms/ClickTreeLabelProvider.java
@@ -0,0 +1,112 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.editor.forms;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
+import org.eclipse.wst.xml.ui.internal.contentoutline.JFaceNodeLabelProvider;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Element;
+import org.w3c.dom.NamedNodeMap;
+
+/**
+ *
+ * @author Naoki Takezoe
+ */
+public class ClickTreeLabelProvider extends JFaceNodeLabelProvider {
+
+	private Map<String, Image> images = new HashMap<String, Image>();
+
+	public ClickTreeLabelProvider(){
+		images.put(ClickPlugin.TAG_CLICK_APP,
+				ClickPlugin.getImageDescriptor("icons/click.gif").createImage());
+		images.put(ClickPlugin.TAG_HEADER,
+				ClickPlugin.getImageDescriptor("icons/header.gif").createImage());
+		images.put(ClickPlugin.TAG_HEADERS,
+				ClickPlugin.getImageDescriptor("icons/folder.gif").createImage());
+		images.put(ClickPlugin.TAG_PAGE,
+				ClickPlugin.getImageDescriptor("icons/page.gif").createImage());
+		images.put(ClickPlugin.TAG_PAGES,
+				ClickPlugin.getImageDescriptor("icons/folder.gif").createImage());
+		images.put(ClickPlugin.TAG_CONTROL,
+				ClickPlugin.getImageDescriptor("icons/control.gif").createImage());
+		images.put(ClickPlugin.TAG_CONTROL_SET,
+				ClickPlugin.getImageDescriptor("icons/control.gif").createImage());
+		images.put(ClickPlugin.TAG_CONTROLS,
+				ClickPlugin.getImageDescriptor("icons/folder.gif").createImage());
+		images.put(ClickPlugin.TAG_EXCLUDES,
+				ClickPlugin.getImageDescriptor("icons/page.gif").createImage());
+		images.put(ClickPlugin.TAG_PROPERTY,
+				ClickPlugin.getImageDescriptor("icons/property.gif").createImage());
+		images.put(ClickPlugin.TAG_FILE_UPLOAD_SERVICE,
+				ClickPlugin.getImageDescriptor("icons/class.gif").createImage());
+		images.put(ClickPlugin.TAG_LOG_SERVICE,
+				ClickPlugin.getImageDescriptor("icons/class.gif").createImage());
+		images.put(ClickPlugin.TAG_TEMPLATE_SERVICE,
+				ClickPlugin.getImageDescriptor("icons/class.gif").createImage());
+		images.put(ClickPlugin.TAG_RESOURCE_SERVICE,
+				ClickPlugin.getImageDescriptor("icons/class.gif").createImage());
+	}
+
+	public void dispose(){
+		for(Iterator<Image> ite = images.values().iterator(); ite.hasNext();){
+			Image image = ite.next();
+			image.dispose();
+		}
+		super.dispose();
+	}
+
+	public String getText(Object object) {
+		if(object instanceof Element){
+			Element element = (Element)object;
+			StringBuffer sb = new StringBuffer();
+			sb.append(element.getNodeName());
+			sb.append(" ");
+			NamedNodeMap attrs = element.getAttributes();
+			for(int i=0;i<attrs.getLength();i++){
+				if(i!=0){
+					sb.append(", ");
+				}
+				Attr attr = (Attr)attrs.item(i);
+				sb.append(attr.getName());
+				sb.append("=");
+				sb.append(attr.getValue());
+			}
+			return sb.toString();
+		}
+		return super.getText(object);
+	}
+
+	public Image getImage(Object object) {
+		if(object instanceof IDOMElement){
+			String name = ((IDOMElement)object).getNodeName();
+			Image image = (Image)images.get(name);
+			if(image != null){
+				return image;
+			}
+		}
+		return super.getImage(object);
+	}
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/fieldassist/FieldAssistUtils.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/fieldassist/FieldAssistUtils.java
new file mode 100644
index 0000000..8df14d7
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/fieldassist/FieldAssistUtils.java
@@ -0,0 +1,164 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.fieldassist;
+
+import java.util.HashMap;
+
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.jdt.core.IBuffer;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.JavaModelException;
+import org.eclipse.jface.fieldassist.IContentProposal;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Label;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class FieldAssistUtils {
+	
+	private static HashMap<IJavaProject, ICompilationUnit> 
+		unitMap = new HashMap<IJavaProject, ICompilationUnit>();
+	
+	/**
+	 * Set contents of the compilation unit to the translated jsp text.
+	 *
+	 * @param unit the ICompilationUnit on which to set the buffer contents
+	 * @param value Java source code
+	 */	
+	public static void setContentsToCU(ICompilationUnit unit, String value){
+		if (unit == null)
+			return;
+
+		synchronized (unit) {
+			IBuffer buffer;
+			try {
+
+				buffer = unit.getBuffer();
+			}
+			catch (JavaModelException e) {
+				e.printStackTrace();
+				buffer = null;
+			}
+
+			if (buffer != null)
+				buffer.setContents(value);
+		}
+	}
+	
+	/**
+	 * Creates the <code>ICompilationUnit</code> to use temporary.
+	 * 
+	 * @param project the java project
+	 * @return the temporary <code>ICompilationUnit</code>
+	 * @throws JavaModelException
+	 */
+	public synchronized static ICompilationUnit getTemporaryCompilationUnit(
+			IJavaProject project) throws JavaModelException {
+		
+		if(unitMap.get(project) != null){
+			return unitMap.get(project);
+		}
+		
+		IPackageFragment root = project.getPackageFragments()[0];
+		ICompilationUnit unit = root.getCompilationUnit("_xxx.java").getWorkingCopy(
+				new NullProgressMonitor());
+		
+		unitMap.put(project, unit);
+		
+		return unit;
+	}
+	
+	public static class ContentProposalImpl implements IContentProposal {
+		
+		private String content;
+		private int position;
+		
+		public ContentProposalImpl(String content, int position){
+			this.content = content;
+			this.position = position;
+		}
+		
+		public String getContent() {
+			return content.substring(position);
+		}
+
+		public int getCursorPosition() {
+			return content.length() - position;
+		}
+
+		public String getDescription() {
+			return null;
+		}
+
+		public String getLabel() {
+			return content;
+		}
+	}
+	
+	/**
+	 * Creates the <code>Composite</code> for the fields which don't need decoration.
+	 * 
+	 * @param parent the parent composite
+	 * @param white whether it should paint out the background
+	 * @return the created <code>Composite</code> object
+	 */
+	public static Composite createNullDecoratedPanel(Composite parent, boolean white){
+		Composite composite = new Composite(parent, SWT.NULL);
+		GridLayout layout = createGridLayout();
+		layout.horizontalSpacing = 0;
+		layout.verticalSpacing = 0;
+		composite.setLayout(layout);
+		if(white){
+			composite.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_WHITE));
+		}
+		Label space = new Label(composite, SWT.NULL);
+		GridData gd = new GridData();
+		gd.widthHint = 7;
+		space.setLayoutData(gd);
+		if(white){
+			space.setBackground(Display.getDefault().getSystemColor(SWT.COLOR_WHITE));
+		}
+		return composite;
+	}
+	
+	/**
+	 * Creates <code>GridLayout</code> that has no margin.
+	 * 
+	 * @return created <code>GridLayout</code> that has no margin
+	 */
+	public static GridLayout createGridLayout(){
+		GridLayout layout = new GridLayout(2, false);
+		layout.marginBottom = 0;
+		layout.marginTop = 0;
+		layout.marginLeft = 0;
+		layout.marginRight = 0;
+		layout.marginWidth = 0;
+		layout.marginHeight = 0;
+		return layout;
+	}	
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/fieldassist/PackageNameContentProposalProvider.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/fieldassist/PackageNameContentProposalProvider.java
new file mode 100644
index 0000000..5b24cf7
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/fieldassist/PackageNameContentProposalProvider.java
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.fieldassist;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner;
+import org.eclipse.jdt.internal.ui.text.java.JavaCompletionProposal;
+import org.eclipse.jdt.internal.ui.text.java.LazyJavaTypeCompletionProposal;
+import org.eclipse.jdt.ui.text.java.CompletionProposalCollector;
+import org.eclipse.jdt.ui.text.java.IJavaCompletionProposal;
+import org.eclipse.jface.fieldassist.IContentProposal;
+import org.eclipse.jface.fieldassist.IContentProposalProvider;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class PackageNameContentProposalProvider implements IContentProposalProvider {
+	
+	private IJavaProject project;
+	
+	/**
+	 * Constructor.
+	 * 
+	 * @param project the Java project
+	 */
+	public PackageNameContentProposalProvider(IJavaProject project){
+		this.project = project;
+	}
+	
+	public void setJavaProject(IJavaProject project){
+		this.project = project;
+	}
+	
+	public IContentProposal[] getProposals(String contents, int position) {
+		if(this.project==null){
+			return null;
+		}
+		try {
+			CompletionProposalCollector collector = new CompletionProposalCollector(project);
+			ICompilationUnit unit = FieldAssistUtils.getTemporaryCompilationUnit(project);
+			contents = contents.substring(0, position);
+			String source = "package " + contents;
+			FieldAssistUtils.setContentsToCU(unit, source);
+			unit.codeComplete(source.length(), collector, DefaultWorkingCopyOwner.PRIMARY);
+			IJavaCompletionProposal[] proposals = collector.getJavaCompletionProposals();
+			List<IContentProposal> result = new ArrayList<IContentProposal>();
+			
+			for(int j=0;j<proposals.length;j++){
+				if(proposals[j].getImage()!=null){
+					String replaceString = null;
+					if(proposals[j] instanceof LazyJavaTypeCompletionProposal){
+						LazyJavaTypeCompletionProposal p = (LazyJavaTypeCompletionProposal)proposals[j];
+						replaceString = p.getReplacementString();
+					} else if(proposals[j] instanceof JavaCompletionProposal){
+						JavaCompletionProposal p = (JavaCompletionProposal)proposals[j];
+						replaceString = p.getReplacementString();
+					}
+					if(replaceString!=null && replaceString.startsWith(contents)){
+						result.add(new FieldAssistUtils.ContentProposalImpl(replaceString, position));
+					}
+				}
+			}
+			
+			return result.toArray(new IContentProposal[result.size()]);
+			
+		} catch(Exception ex){
+			ex.printStackTrace();
+		}
+		
+		return null;
+	}
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/fieldassist/TypeNameContentProposalProvider.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/fieldassist/TypeNameContentProposalProvider.java
new file mode 100644
index 0000000..79f1bbe
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/fieldassist/TypeNameContentProposalProvider.java
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.fieldassist;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.internal.core.DefaultWorkingCopyOwner;
+import org.eclipse.jdt.internal.ui.text.java.JavaCompletionProposal;
+import org.eclipse.jdt.internal.ui.text.java.LazyJavaTypeCompletionProposal;
+import org.eclipse.jdt.ui.text.java.CompletionProposalCollector;
+import org.eclipse.jdt.ui.text.java.IJavaCompletionProposal;
+import org.eclipse.jface.fieldassist.IContentProposal;
+import org.eclipse.jface.fieldassist.IContentProposalProvider;
+
+/**
+ * Provides type name completion in the Java project.
+ * 
+ * @author Naoki Takezoe
+ */
+public class TypeNameContentProposalProvider implements IContentProposalProvider {
+	
+	private IJavaProject project;
+	
+	/**
+	 * Constructor.
+	 * 
+	 * @param project the Java project
+	 */
+	public TypeNameContentProposalProvider(IJavaProject project){
+		this.project = project;
+	}
+	
+	public void setJavaProject(IJavaProject project){
+		this.project = project;
+	}
+	
+	public IContentProposal[] getProposals(String contents, int position) {
+		try {
+			CompletionProposalCollector collector = new CompletionProposalCollector(project);
+			ICompilationUnit unit = FieldAssistUtils.getTemporaryCompilationUnit(project);
+			contents = contents.substring(0, position);
+			String source = "public class _xxx { public static void hoge(){ " + contents + "}}";
+			FieldAssistUtils.setContentsToCU(unit, source);
+			unit.codeComplete(source.length() - 2, collector, DefaultWorkingCopyOwner.PRIMARY);
+			IJavaCompletionProposal[] proposals = collector.getJavaCompletionProposals();
+			List<IContentProposal> result = new ArrayList<IContentProposal>();
+			
+			for(int j=0;j<proposals.length;j++){
+				if(proposals[j].getImage()!=null){
+					String replaceString = null;
+					if(proposals[j] instanceof LazyJavaTypeCompletionProposal){
+						LazyJavaTypeCompletionProposal p = (LazyJavaTypeCompletionProposal)proposals[j];
+						replaceString = p.getReplacementString();
+					} else if(proposals[j] instanceof JavaCompletionProposal){
+						JavaCompletionProposal p = (JavaCompletionProposal)proposals[j];
+						replaceString = p.getReplacementString();
+					}
+					if(replaceString!=null && replaceString.startsWith(contents)){
+						result.add(new FieldAssistUtils.ContentProposalImpl(replaceString, position));
+					}
+				}
+			}
+			
+			return result.toArray(new IContentProposal[result.size()]);
+			
+		} catch(Exception ex){
+			ex.printStackTrace();
+		}
+		
+		return null;
+	}
+
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/ClickFacetWizardPage.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/ClickFacetWizardPage.java
new file mode 100644
index 0000000..51877a7
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/ClickFacetWizardPage.java
@@ -0,0 +1,107 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.wizard;
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.core.facet.ClickFacetInstallDataModelProvider;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.wst.common.frameworks.datamodel.IDataModel;
+import org.eclipse.wst.common.project.facet.ui.AbstractFacetWizardPage;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ * @since 2.0.0
+ */
+public class ClickFacetWizardPage extends AbstractFacetWizardPage {
+	
+	private IDataModel model;
+	private Text rootPackage;
+	private Button useSpring;
+	private Button useCayenne;
+	private Button usePerformanceFilter;
+	
+	public ClickFacetWizardPage() {
+		super("ClickFacetWizardPage");
+		setTitle(ClickPlugin.getString("wizard.facet.title"));
+		setDescription(ClickPlugin.getString("wizard.facet.description"));
+	}
+
+	public void setConfig(Object config) {
+		this.model = (IDataModel) config;
+	}
+
+	public void createControl(Composite parent) {
+		Composite composite = new Composite(parent, SWT.NULL);
+		composite.setLayout(new GridLayout(2, false));
+		
+		ClickUtils.createLabel(composite, ClickPlugin.getString("wizard.facet.rootPackage"));
+		rootPackage = new Text(composite, SWT.BORDER);
+		rootPackage.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		rootPackage.addModifyListener(new ModifyListener() {
+			public void modifyText(ModifyEvent e) {
+				doValidate();
+			}
+		});
+		
+		usePerformanceFilter = new Button(composite, SWT.CHECK);
+		usePerformanceFilter.setText(ClickPlugin.getString("wizard.facet.usePerformanceFilter"));
+		usePerformanceFilter.setLayoutData(ClickUtils.createGridData(2, GridData.FILL_HORIZONTAL));
+		
+		useSpring = new Button(composite, SWT.CHECK);
+		useSpring.setText(ClickPlugin.getString("wizard.facet.useSpring"));
+		useSpring.setLayoutData(ClickUtils.createGridData(2, GridData.FILL_HORIZONTAL));
+		
+		useCayenne = new Button(composite, SWT.CHECK);
+		useCayenne.setText(ClickPlugin.getString("wizard.facet.useCayenne"));
+		useCayenne.setLayoutData(ClickUtils.createGridData(2, GridData.FILL_HORIZONTAL));
+		
+		setControl(composite);
+		doValidate();
+	}
+	
+	private void doValidate(){
+		if(rootPackage.getText().length() == 0){
+			setErrorMessage(ClickPlugin.getString("wizard.facet.error.rootPackage.empty"));
+			setPageComplete(false);
+		} else {
+			setErrorMessage(null);
+			setPageComplete(true);
+		}
+	}
+
+	public void transferStateToConfig() {
+		model.setBooleanProperty(ClickFacetInstallDataModelProvider.USE_PERFORMANCE_FILTER, 
+				usePerformanceFilter.getSelection());
+		model.setBooleanProperty(ClickFacetInstallDataModelProvider.USE_SPRING, 
+				useSpring.getSelection());
+		model.setBooleanProperty(ClickFacetInstallDataModelProvider.USE_CAYENNE, 
+				useCayenne.getSelection());
+		model.setStringProperty(ClickFacetInstallDataModelProvider.ROOT_PACKAGE, 
+				rootPackage.getText());
+	}
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/NewClassWizard.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/NewClassWizard.java
new file mode 100644
index 0000000..224f38f
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/NewClassWizard.java
@@ -0,0 +1,77 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.wizard;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.internal.ui.wizards.NewClassCreationWizard;
+import org.eclipse.jdt.ui.wizards.NewClassWizardPage;
+
+/**
+ * 
+ * @author Naoki Takezoe
+ */
+public class NewClassWizard extends NewClassCreationWizard {
+
+	private String superClass;
+	private String className;
+	private List<String> implement;
+	
+	public NewClassWizard() {
+		super();
+	}
+	
+	public void setSuperClass(String superClass){
+		this.superClass = superClass;
+	}
+	
+	public void setClassName(String className){
+		this.className = className;
+	}
+	
+	public void addInterface(String implement){
+		if(this.implement==null){
+			this.implement = new ArrayList<String>();
+		}
+		this.implement.add(implement);
+	}
+	
+	public void addPages() {
+		super.addPages();
+		NewClassWizardPage fPage = (NewClassWizardPage)getPages()[0];
+		if(superClass!=null){
+			fPage.setSuperClass(superClass, true);
+		}
+		if(implement!=null){
+			fPage.setSuperInterfaces(implement, true);
+		}
+		if(className!=null){
+			int index = className.lastIndexOf('.');
+			if(index!=-1){
+				String packageName = className.substring(0,index);
+				className = className.substring(index+1,className.length());
+				IPackageFragment pack = fPage.getPackageFragmentRoot().getPackageFragment(packageName);
+				fPage.setPackageFragment(pack,true);
+			}
+			fPage.setTypeName(className,true);
+		}
+	}
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/NewClickPageWizard.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/NewClickPageWizard.java
new file mode 100644
index 0000000..ddd9de3
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/NewClickPageWizard.java
@@ -0,0 +1,342 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.wizard;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.List;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.preferences.Template;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jface.dialogs.IDialogSettings;
+import org.eclipse.jface.operation.IRunnableWithProgress;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.jface.wizard.Wizard;
+import org.eclipse.ui.INewWizard;
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.PartInitException;
+import org.eclipse.ui.ide.IDE;
+import org.eclipse.wst.sse.core.StructuredModelManager;
+import org.eclipse.wst.sse.core.internal.provisional.IModelManager;
+import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMDocument;
+import org.eclipse.wst.xml.core.internal.provisional.document.IDOMModel;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+/**
+ * The wizard to create new click page.
+ * 
+ * @author Naoki Takezoe
+ */
+public class NewClickPageWizard extends Wizard implements INewWizard {
+	
+	// keys of dialog settings
+	public static final String SECTION_NEW_CLICK_PAGE = "NewClickPageWizard";
+	public static final String SHOULD_CREATE_HTML = "shouldCreateHTML";
+	public static final String SHOULD_CREATE_CLASS = "shouldCreateClass";
+	public static final String SHOULD_ADD_TO_CLICK_XML = "shouldAddToClickXML";
+	public static final String SUPERCLASS = "superclass";
+	
+	private IStructuredSelection selection;
+	private NewClickPageWizardPage page;
+	private String initialPageName = null;
+	private String initialClassName = null;
+	private IFile[] openFiles = null;
+	
+	public NewClickPageWizard() {
+		super();
+		setNeedsProgressMonitor(true);
+		setWindowTitle(ClickPlugin.getString("wizard.newPage.title"));
+		
+		IDialogSettings settings = ClickPlugin.getDefault().getDialogSettings();
+		if(settings.getSection(SECTION_NEW_CLICK_PAGE)==null){
+			IDialogSettings section = settings.addNewSection(SECTION_NEW_CLICK_PAGE);
+			section.put(SHOULD_CREATE_HTML, true);
+			section.put(SHOULD_CREATE_CLASS, true);
+			section.put(SHOULD_ADD_TO_CLICK_XML, false);
+			section.put(SUPERCLASS, "org.apache.click.Page");
+		}
+		setDialogSettings(settings.getSection(SECTION_NEW_CLICK_PAGE));
+	}
+	
+	public void init(IWorkbench workbench, IStructuredSelection selection) {
+		this.selection = selection;
+	}
+	
+	public void setInitialClassName(String className){
+		this.initialClassName =  className;
+	}
+	
+	public void setInitialPageName(String pageName){
+		this.initialPageName = pageName;
+	}
+	
+	public void addPages() {
+		Object element = null;
+		if(selection != null){
+			element = selection.getFirstElement();
+		}
+		page = new NewClickPageWizardPage("page1", element, 
+				this.initialClassName, this.initialPageName);
+		addPage(page);
+	}
+	
+	public boolean performFinish(){
+		
+		final boolean shouldCreateHTML = page.shouldCreateHTML();
+		final boolean shouldCreateClass = page.shouldCreateClass();
+		final boolean shouldAddToClickXML = page.shouldAddToClickXML();
+		final String parentFolder = page.getParentFolder();
+		final String filename = page.getFilename();
+		final String sourceFolder = page.getSourceFolder();
+		final String packageName = page.getPackageName();
+		final String className = page.getClassName();
+		final String superClass = page.getSuperClass();
+		final Template template = page.getTemplate();
+		final IProject project = page.getProject();
+		
+		IDialogSettings settings = getDialogSettings();
+		settings.put(SHOULD_CREATE_HTML, shouldCreateHTML);
+		settings.put(SHOULD_CREATE_CLASS, shouldCreateClass);
+		settings.put(SHOULD_ADD_TO_CLICK_XML, shouldAddToClickXML);
+		settings.put(SUPERCLASS, superClass);
+		
+		IRunnableWithProgress op = new IRunnableWithProgress() {
+			public void run(IProgressMonitor monitor) throws InvocationTargetException {
+				try {
+					openFiles = doFinish(monitor, project, shouldCreateHTML, shouldCreateClass, shouldAddToClickXML,
+							parentFolder, filename, sourceFolder, packageName, className, superClass, template);
+				} catch (Exception e) {
+					throw new InvocationTargetException(e);
+				} finally {
+					monitor.done();
+				}
+			}
+		};
+		try {
+			getContainer().run(true, false, op);
+			for(int i=0;i<openFiles.length;i++){
+				IDE.openEditor(ClickUtils.getActivePage(), openFiles[i]);
+			}
+		} catch (PartInitException e){
+			// TODO display the error message?
+			ClickPlugin.log(e);
+		} catch (InterruptedException e) {
+			// TODO display the error message?
+			ClickPlugin.log(e);
+			return false;
+		} catch (InvocationTargetException e) {
+			// TODO display the error message?
+			Throwable realException = e.getTargetException();
+			ClickPlugin.log(realException);
+			return false;
+		}
+		return true;
+	}
+	
+	private IFile[] doFinish(IProgressMonitor monitor, IProject project,
+			boolean shouldCreateHTML,boolean shouldCreateClass, boolean shouldAddToClickXML,
+			String parentFolder, String filename, String sourceFolder, String packageName,
+			String className, String superClass, Template template) throws Exception {
+		
+		List<IFile> files = new ArrayList<IFile>();
+		int totalTask = 0;
+		if(shouldCreateHTML){
+			totalTask++;
+		}
+		if(shouldCreateClass){
+			totalTask++;
+		}
+		if(shouldAddToClickXML){
+			totalTask++;
+		}
+		monitor.beginTask(ClickPlugin.getString("wizard.newPage.progress"), totalTask);
+		
+		// Creates the HTML file
+		if(shouldCreateHTML){
+			try {
+				IFile file = null;
+				if(parentFolder.equals("")){
+					file = project.getFile(filename);
+				} else {
+					IFolder folder = project.getFolder(parentFolder);
+//					if(!folder.exists()){
+//						folder.create(true, true, new NullProgressMonitor());
+//					}
+					file = folder.getFile(filename);
+				}
+				if(!file.exists()){
+					String charset = ClickUtils.getCharset(project);
+					if(charset==null){
+						charset = file.getCharset();
+					}
+					file.create(getTemplateInputStream(template, charset), true, new NullProgressMonitor());
+				}
+				files.add(file);
+			} finally {
+				monitor.worked(1);
+			}
+		}
+		
+		// Creates the page class
+		if(shouldCreateClass){
+			try {
+				IResource resource = project;
+				if(!sourceFolder.equals("")){
+					resource = project.getFolder(sourceFolder);
+				}
+				
+				IJavaProject javaProject = JavaCore.create(project);
+				IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(resource);
+				IPackageFragment fragment = root.getPackageFragment(packageName);
+				if(!fragment.exists()){
+					root.createPackageFragment(packageName, true, new NullProgressMonitor());
+					fragment = root.getPackageFragment(packageName);
+				}
+				ICompilationUnit unit = fragment.getCompilationUnit(className+".java");
+				if(!unit.exists()){
+					IFile file = (IFile)unit.getResource();
+					file.create(getPageClassInputStream(template, packageName, className, superClass),
+							true, new NullProgressMonitor());
+					files.add(file);
+				}
+			} finally {
+				monitor.worked(1);
+			}
+		}
+		
+		// Adds the page mapping to the click.xml
+		if(shouldAddToClickXML){
+			IStructuredModel model = null;
+			
+			String newPath = filename;
+			String webAppRoot = ClickUtils.getWebAppRootFolder(project);
+			if(parentFolder.startsWith(webAppRoot)){
+				parentFolder = parentFolder.substring(webAppRoot.length()).replaceAll("^/|/$","");
+				if(parentFolder.length() > 0){
+					newPath = parentFolder + "/" + filename;
+				}
+			}
+			
+			try {
+				IFile file = ClickUtils.getClickConfigFile(project);
+				IModelManager manager = StructuredModelManager.getModelManager();
+				model = manager.getModelForEdit(file);
+				
+				IDOMDocument doc = ((IDOMModel)model).getDocument();
+				
+				Element root  = doc.getDocumentElement();
+				Element pages = null;
+				NodeList list = doc.getElementsByTagName(ClickPlugin.TAG_PAGES);
+				
+				if(list.getLength()==0){
+					pages = doc.createElement(ClickPlugin.TAG_PAGES);
+					boolean inserted = false;
+					NodeList children = root.getChildNodes();
+					for(int i=0;i<children.getLength();i++){
+						Node node = children.item(i);
+						if(node instanceof Element){
+							root.insertBefore(pages, node);
+							inserted = true;
+							break;
+						}
+					}
+					if(!inserted){
+						root.appendChild(pages);
+					}
+				} else {
+					pages = (Element)list.item(0);
+				}
+				
+				NodeList children = pages.getChildNodes();
+				boolean found = false;
+				
+				String newClazz = className;
+				String pagesPackage = pages.getAttribute(ClickPlugin.ATTR_PACKAGE);
+				if(packageName.length()!=0){
+					if(pagesPackage==null || !packageName.equals(pagesPackage)){
+						newClazz = packageName + "." + className;
+					}
+				}
+				
+				for(int i=0;i<children.getLength();i++){
+					Node node = children.item(i);
+					if(node instanceof Element && ((Element)node).getNodeName().equals(ClickPlugin.TAG_PAGE)){
+						Element page = (Element)node;
+						String path  = page.getAttribute(ClickPlugin.ATTR_PATH);
+						String clazz = page.getAttribute(ClickPlugin.ATTR_CLASSNAME);
+						if(newPath.equals(path) && newClazz.equals(clazz)){
+							found = true;
+							break;
+						}
+					}
+				}
+				if(!found){
+					Element page = doc.createElement(ClickPlugin.TAG_PAGE);
+					page.setAttribute(ClickPlugin.ATTR_PATH, newPath);
+					page.setAttribute(ClickPlugin.ATTR_CLASSNAME, newClazz);
+					pages.appendChild(page);
+				}
+				model.save();
+			} finally {
+				if(model!=null){
+					model.releaseFromEdit();
+				}
+				monitor.worked(1);
+			}
+		}
+		
+		return (IFile[])files.toArray(new IFile[files.size()]);
+	}
+	
+	private InputStream getTemplateInputStream(Template template, String charset){
+		String source = new String(template.getHtmlTemplate());
+		source = source.replaceAll("\\$\\{charset\\}", charset);
+		return new ByteArrayInputStream(source.getBytes());
+	}
+	
+	private InputStream getPageClassInputStream(Template template,
+			String packageName, String className, String superClass){
+		
+		String source = new String(template.getPageClass());
+		source = source.replaceAll("\\$\\{package\\}", packageName);
+		source = source.replaceAll("\\$\\{classname\\}", className);
+		source = source.replaceAll("\\$\\{superclass\\}", superClass);
+		
+		return new ByteArrayInputStream(source.getBytes());
+	}
+	
+}
diff --git a/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/NewClickPageWizardPage.java b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/NewClickPageWizardPage.java
new file mode 100644
index 0000000..78d02b5
--- /dev/null
+++ b/org.apache.click.eclipse/src/org/apache/click/eclipse/ui/wizard/NewClickPageWizardPage.java
@@ -0,0 +1,875 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.click.eclipse.ui.wizard;
+
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.StringTokenizer;
+
+
+import org.apache.click.eclipse.ClickPlugin;
+import org.apache.click.eclipse.ClickUtils;
+import org.apache.click.eclipse.preferences.Template;
+import org.apache.click.eclipse.ui.fieldassist.FieldAssistUtils;
+import org.apache.click.eclipse.ui.fieldassist.PackageNameContentProposalProvider;
+import org.apache.click.eclipse.ui.fieldassist.TypeNameContentProposalProvider;
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.resources.IFolder;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jdt.core.IJavaElement;
+import org.eclipse.jdt.core.IJavaModel;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.IPackageFragment;
+import org.eclipse.jdt.core.IPackageFragmentRoot;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.JavaCore;
+import org.eclipse.jdt.core.search.SearchEngine;
+import org.eclipse.jdt.internal.core.JarPackageFragmentRoot;
+import org.eclipse.jdt.internal.core.JavaProject;
+import org.eclipse.jdt.internal.core.search.JavaSearchScope;
+import org.eclipse.jdt.internal.ui.dialogs.PackageSelectionDialog;
+import org.eclipse.jdt.internal.ui.dialogs.StatusInfo;
+import org.eclipse.jdt.internal.ui.util.BusyIndicatorRunnableContext;
+import org.eclipse.jdt.internal.ui.wizards.TypedElementSelectionValidator;
+import org.eclipse.jdt.internal.ui.wizards.TypedViewerFilter;
+import org.eclipse.jdt.internal.ui.wizards.buildpaths.FolderSelectionDialog;
+import org.eclipse.jdt.ui.IJavaElementSearchConstants;
+import org.eclipse.jdt.ui.JavaUI;
+import org.eclipse.jface.dialogs.IDialogSettings;
+import org.eclipse.jface.dialogs.ProgressMonitorDialog;
+import org.eclipse.jface.fieldassist.TextContentAdapter;
+import org.eclipse.jface.fieldassist.TextControlCreator;
+import org.eclipse.jface.operation.IRunnableContext;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.jface.viewers.ViewerFilter;
+import org.eclipse.jface.wizard.WizardPage;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.FocusAdapter;
+import org.eclipse.swt.events.FocusEvent;
+import org.eclipse.swt.events.ModifyEvent;
+import org.eclipse.swt.events.ModifyListener;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Combo;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Group;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.ui.dialogs.ISelectionStatusValidator;
+import org.eclipse.ui.dialogs.SelectionDialog;
+import org.eclipse.ui.fieldassist.ContentAssistField;
+import org.eclipse.ui.model.WorkbenchContentProvider;
+import org.eclipse.ui.model.WorkbenchLabelProvider;
+import org.eclipse.ui.texteditor.ITextEditorActionDefinitionIds;
+
+/**
+ * <ul>
+ *   <li>TODO Reload initial values when the project is selected.</li>
+ * </ul>
+ * 
+ * @author Naoki Takezoe
+ */
+public class NewClickPageWizardPage extends WizardPage {
+	
+	private List templates = Template.loadFromPreference();
+	private Combo template;
+	private Text project;
+	private Button browseProject;
+	private Button createPageHTML;
+	private Text parentFolder;
+	private Button browseParent;
+	private Text pageName;
+	private Button createPageClass;
+	private Text sourceFolder;
+	private Text packageName;
+	private Text superClass;
+	private Text className;
+	private Button browseSource;
+	private Button browsePackage;
+	private Button browseSuperClass;
+	private Button addToClickXML;
+	
+	private Object selection;
+	private String initialClassName;
+	private String initialPageName;
+	private boolean insertClassName = true;
+	private TypeNameContentProposalProvider typeAssistProvider = null;
+	private PackageNameContentProposalProvider packageAssistProvider = null;
+	
+	public NewClickPageWizardPage(String pageName, Object selection, 
+			String initialClassName, String initialPageName) {
+		super(pageName);
+		
+		this.selection = selection;
+		this.initialClassName = initialClassName;
+		this.initialPageName = initialPageName;
+		
+		setTitle(ClickPlugin.getString("wizard.newPage.title"));
+		setDescription(ClickPlugin.getString("wizard.newPage.description"));
+	}
+	
+	public void createControl(Composite parent) {
+		IDialogSettings settings = 
+			ClickPlugin.getDefault().getDialogSettings().getSection(
+					NewClickPageWizard.SECTION_NEW_CLICK_PAGE);
+		
+		String initClassName = this.initialClassName;
+		String initPackage = "";
+		if(this.initialClassName != null){
+			int index = this.initialClassName.lastIndexOf('.');
+			if(index >= 0){
+				initPackage   = this.initialClassName.substring(0, index);
+				initClassName = this.initialClassName.substring(index + 1);
+			}
+		}
+		
+		Composite composite = new Composite(parent, SWT.NULL);
+		
+		composite.setLayoutData(new GridData(GridData.FILL_BOTH));
+		composite.setLayout(new GridLayout(1, false));
+		
+		Composite projectPanel = new Composite(composite, SWT.NULL);
+		GridLayout layout = new GridLayout(3, false);
+		projectPanel.setLayout(layout);
+		projectPanel.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		ClickUtils.createLabel(projectPanel, ClickPlugin.getString("wizard.newPage.project"));
+		
+		project = new Text(projectPanel, SWT.BORDER);
+		project.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		
+		IJavaProject initProject = null;
+		
+		if(selection!=null){
+			initProject = ClickUtils.getJavaProject(selection);
+			try {
+				if(initProject!=null && initProject.getProject().hasNature(JavaCore.NATURE_ID)){
+					project.setText(initProject.getElementName());
+				}
+			} catch(Exception ex){}
+		}
+		project.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				validate();
+			}
+		});
+		browseProject = new Button(projectPanel, SWT.PUSH);
+		browseProject.setText(ClickPlugin.getString("action.browse"));
+		browseProject.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				selectProject();
+				validate();
+			}
+		});
+		
+		packageAssistProvider = new PackageNameContentProposalProvider(initProject);
+		typeAssistProvider = new TypeNameContentProposalProvider(initProject);
+		
+		ClickUtils.createLabel(projectPanel, ClickPlugin.getString("preferences.template") + ":");
+		template = new Combo(projectPanel, SWT.READ_ONLY);
+		for(int i=0;i<templates.size();i++){
+			template.add(((Template)templates.get(i)).getName());
+			if(i==0){
+				template.setText(((Template)templates.get(i)).getName());
+			}
+		}
+		
+		Group htmlGroup = new Group(composite, SWT.NULL);
+		htmlGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		htmlGroup.setLayout(new GridLayout(3, false));
+		htmlGroup.setText(ClickPlugin.getString("wizard.newPage.templateGroup"));
+		
+		createPageHTML = new Button(htmlGroup, SWT.CHECK);
+		createPageHTML.setText(ClickPlugin.getString("wizard.newPage.templateGroup.checkbox"));
+		createPageHTML.setLayoutData(createGridData(3));
+		createPageHTML.setSelection(settings.getBoolean(NewClickPageWizard.SHOULD_CREATE_HTML));
+		createPageHTML.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				updateHTMLGroup();
+				validate();
+			}
+		});
+		
+		String initFolder = "";
+		String initPageName = this.initialPageName;
+		if(initPageName!=null){
+			int index = initPageName.indexOf('/');
+			if(index >= 0){
+				initFolder   = initPageName.substring(0, index);
+				initPageName = initPageName.substring(index + 1);
+				if(!initFolder.startsWith("/")){
+					initFolder = "/" + initFolder;
+				}
+			}
+		}
+		
+		ClickUtils.createLabel(htmlGroup, ClickPlugin.getString("wizard.newPage.templateGroup.parentFolder"));
+		parentFolder = new Text(htmlGroup, SWT.BORDER);
+		parentFolder.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		if(selection instanceof IFolder){
+			parentFolder.setText(((IFolder)selection).getProjectRelativePath().toString() + initFolder);
+		} else if(selection!=null){
+			IJavaProject project = ClickUtils.getJavaProject(selection);
+			if(project!=null){
+				parentFolder.setText(ClickUtils.getWebAppRootFolder(project.getProject()) + initFolder);
+			}
+		}
+		parentFolder.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				validate();
+			}
+		});
+		
+		browseParent = new Button(htmlGroup, SWT.PUSH);
+		browseParent.setText(ClickPlugin.getString("action.browse"));
+		browseParent.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				selectFolder();
+			}
+		});
+		
+		ClickUtils.createLabel(htmlGroup, ClickPlugin.getString("wizard.newPage.templateGroup.filename"));
+		pageName = new Text(htmlGroup, SWT.BORDER);
+		pageName.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		if(initPageName!=null){
+			pageName.setText(initPageName);
+		}
+		pageName.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				if(className.getText().length()==0){
+					insertClassName = true;
+				}
+				if(insertClassName && createPageClass.getSelection()){
+					String page = pageName.getText(); //.replaceFirst("\\..*?$", "");
+					int index = page.lastIndexOf('.');
+					if(index >= 0){
+						page = page.substring(0, index);
+					}
+			        StringTokenizer tokenizer = new StringTokenizer(page, "_-");
+			        String name = "";
+			        while (tokenizer.hasMoreTokens()) {
+			            String token = tokenizer.nextToken();
+			            token = Character.toUpperCase(token.charAt(0)) + token.substring(1);
+			            name += token;
+			        }
+					className.setText(name);
+				}
+				validate();
+			}
+		});
+		pageName.addFocusListener(new FocusAdapter(){
+			public void focusLost(FocusEvent e) {
+				insertClassName = className.getText().length()==0;
+			}
+		});
+		
+		Group classGroup = new Group(composite, SWT.NULL);
+		classGroup.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		classGroup.setLayout(new GridLayout(3, false));
+		classGroup.setText(ClickPlugin.getString("wizard.newPage.pageClassGroup"));
+		
+		createPageClass = new Button(classGroup, SWT.CHECK);
+		createPageClass.setText(ClickPlugin.getString("wizard.newPage.pageClassGroup.checkbox"));
+		createPageClass.setLayoutData(createGridData(3));
+		createPageClass.setSelection(settings.getBoolean(NewClickPageWizard.SHOULD_CREATE_CLASS));
+		createPageClass.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				updateClassGroup();
+				validate();
+			}
+		});
+		
+		ClickUtils.createLabel(classGroup, ClickPlugin.getString("wizard.newPage.pageClassGroup.sourceFolder"));
+		Composite sourceField = FieldAssistUtils.createNullDecoratedPanel(classGroup, false);
+		sourceFolder = new Text(sourceField, SWT.BORDER);
+		sourceField.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		sourceFolder.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		IPackageFragmentRoot root = ClickUtils.getSourceFolder(selection);
+		if(root!=null){
+			sourceFolder.setText(root.getElementName());
+		} else if(selection!=null){
+			try {
+				IJavaProject project = ClickUtils.getJavaProject(selection);
+				if(project!=null){
+					IPackageFragmentRoot[] roots = project.getPackageFragmentRoots();
+					if(roots.length >= 1){
+						sourceFolder.setText(roots[0].getElementName());
+					}
+				}
+			} catch(Exception ex){
+				ClickPlugin.log(ex);
+			}
+		}
+		sourceFolder.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				validate();
+			}
+		});
+		
+		browseSource = new Button(classGroup, SWT.PUSH);
+		browseSource.setText(ClickPlugin.getString("action.browse"));
+		browseSource.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				selectSourceFolder();
+			}
+		});
+		
+		ClickUtils.createLabel(classGroup, ClickPlugin.getString("wizard.newPage.pageClassGroup.package"));
+		ContentAssistField packageField = new ContentAssistField(classGroup, SWT.BORDER,
+				new TextControlCreator(), new TextContentAdapter(), packageAssistProvider,
+				ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS, new char[0]);
+		packageName = (Text)packageField.getControl();
+		packageField.getLayoutControl().setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		
+		if(selection instanceof IPackageFragment){
+			packageName.setText(((IPackageFragment)selection).getElementName());
+		} else if(initPackage!=null && initPackage.length()!=0){
+			packageName.setText(initPackage);
+		} else if(getProject()!=null){
+			String pagesPackage = ClickUtils.getPagePackageName(getProject());
+			if(pagesPackage != null){
+				packageName.setText(pagesPackage);
+			}
+		}
+		packageName.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				validate();
+			}
+		});
+		
+		browsePackage = new Button(classGroup, SWT.PUSH);
+		browsePackage.setText(ClickPlugin.getString("action.browse"));
+		browsePackage.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				IRunnableContext context= new BusyIndicatorRunnableContext();
+				int style = PackageSelectionDialog.F_REMOVE_DUPLICATES | 
+				            PackageSelectionDialog.F_SHOW_PARENTS | 
+				            PackageSelectionDialog.F_HIDE_DEFAULT_PACKAGE;
+				
+				JavaSearchScope scope = new JavaSearchScope();
+				try {
+					IJavaProject project = JavaCore.create(getProject());
+					scope.add((JavaProject)project, JavaSearchScope.SOURCES, new HashSet(2, 1));
+				} catch(Exception ex){
+					ClickPlugin.log(ex);
+				}
+				
+				PackageSelectionDialog dialog = new PackageSelectionDialog(getShell(), context, style, scope);
+				dialog.setMultipleSelection(false);
+				if(dialog.open()==PackageSelectionDialog.OK){
+					Object[] result = dialog.getResult();
+					if(result.length >= 1){
+						IPackageFragment fragment = (IPackageFragment)result[0];
+						packageName.setText(fragment.getElementName());
+					}
+				}
+			}
+		});
+		
+		ClickUtils.createLabel(classGroup, ClickPlugin.getString("wizard.newPage.pageClassGroup.classname"));
+		Composite classField = FieldAssistUtils.createNullDecoratedPanel(classGroup, false);
+		className = new Text(classField, SWT.BORDER);
+		classField.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		className.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		if(initClassName!=null){
+			className.setText(initClassName);
+		}
+		className.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				validate();
+			}
+		});
+		
+		ClickUtils.createLabel(classGroup, "");
+		
+		ClickUtils.createLabel(classGroup, ClickPlugin.getString("wizard.newPage.pageClassGroup.superclass"));
+		ContentAssistField superClassField = new ContentAssistField(classGroup, SWT.BORDER,
+				new TextControlCreator(), new TextContentAdapter(), typeAssistProvider,
+				ITextEditorActionDefinitionIds.CONTENT_ASSIST_PROPOSALS, new char[0]);
+		superClass = (Text)superClassField.getControl();
+		superClassField.getLayoutControl().setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
+		superClass.setText(settings.get(NewClickPageWizard.SUPERCLASS));
+		superClass.addModifyListener(new ModifyListener(){
+			public void modifyText(ModifyEvent e){
+				validate();
+			}
+		});
+		browseSuperClass = new Button(classGroup, SWT.PUSH);
+		browseSuperClass.setText(ClickPlugin.getString("action.browse"));
+		browseSuperClass.addSelectionListener(new SelectionAdapter(){
+			public void widgetSelected(SelectionEvent evt){
+				Shell shell = getShell();
+				try {
+					IJavaProject project = JavaCore.create(getProject());
+					
+					SelectionDialog dialog = JavaUI.createTypeDialog(
+							shell, new ProgressMonitorDialog(shell),
+							SearchEngine.createJavaSearchScope(new IJavaElement[]{project}),
+							IJavaElementSearchConstants.CONSIDER_CLASSES,false);
+					
+					if(dialog.open()==SelectionDialog.OK){
+						Object[] result = dialog.getResult();
+						superClass.setText(((IType)result[0]).getFullyQualifiedName());
+					}
+				} catch(Exception ex){
+					ClickPlugin.log(ex);
+				}
+			}
+		});
+		
+		ClickUtils.createLabel(composite, "");
+		
+		addToClickXML = new Button(composite, SWT.CHECK);
+		addToClickXML.setText(ClickPlugin.getString("wizard.newPage.addMapping"));
+		addToClickXML.setSelection(settings.getBoolean(NewClickPageWizard.SHOULD_ADD_TO_CLICK_XML));
+		if(getProject()!=null && ClickUtils.getAutoMapping(getProject())){
+			addToClickXML.setSelection(false);
+		}
+		
+		updateHTMLGroup();
+		updateClassGroup();
+		validate();
+		setControl(composite);
+	}
+	
+	private void updateHTMLGroup(){
+		parentFolder.setEnabled(createPageHTML.getSelection());
+		browseParent.setEnabled(createPageHTML.getSelection());
+		pageName.setEnabled(createPageHTML.getSelection());
+	}
+	
+	private void updateClassGroup(){
+		sourceFolder.setEnabled(createPageClass.getSelection());
+		browseSource.setEnabled(createPageClass.getSelection());
+		packageName.setEnabled(createPageClass.getSelection());
+		browsePackage.setEnabled(createPageClass.getSelection());
+		className.setEnabled(createPageClass.getSelection());
+		superClass.setEnabled(createPageClass.getSelection());
+		browseSuperClass.setEnabled(createPageClass.getSelection());
+	}
+	
+	private void validate(){
+		IProject project = getProject();
+		if(project!=null){
+			packageAssistProvider.setJavaProject(JavaCore.create(project));
+		}
+		if(project==null){
+			setMessage(ClickPlugin.getString("wizard.newPage.error.selectProject"), ERROR);
+			setPageComplete(false);
+			browsePackage.setEnabled(false);
+			browseParent.setEnabled(false);
+			browseSource.setEnabled(false);
+			return;
+		} else if(!ClickUtils.isClickProject(getProject())){
+			setMessage(MessageFormat.format(
+					ClickPlugin.getString("wizard.newPage.error.notClickProject"), 
+					new String[]{ getProject().getName() }), ERROR);
+			setPageComplete(false);
+			browsePackage.setEnabled(false);
+			browseParent.setEnabled(false);
+			browseSource.setEnabled(false);
+			return;
+		} else {
+			browsePackage.setEnabled(createPageClass.getSelection());
+			browseParent.setEnabled(createPageClass.getSelection());
+			browseSource.setEnabled(createPageHTML.getSelection());
+		}
+		
+		if(createPageHTML.getSelection() || createPageClass.getSelection()){
+			if(template.getText().length()==0){
+				setMessage(ClickPlugin.getString("wizard.newPage.error.noTemplate"), ERROR);
+				setPageComplete(false);
+				return;
+			}
+		}
+		
+		// for the HTML file part
+		if(createPageHTML.getSelection()){
+			if(!existsFolder(parentFolder.getText())){
+				setMessage(MessageFormat.format(
+						ClickPlugin.getString("wizard.newPage.error.folderDoesNotExist"),
+						new String[]{ parentFolder.getText() }), ERROR);
+				setPageComplete(false);
+				return;
+			} else if(pageName.getText().equals("")){
+				setMessage(ClickPlugin.getString("wizard.newPage.error.pageIsEmpty"), ERROR);
+				setPageComplete(false);
+				return;
+			} else if(existsFile(parentFolder.getText(), pageName.getText())){
+				setMessage(ClickPlugin.getString("wizard.newPage.error.fileAlreadyExists"), ERROR);
+				setPageComplete(false);
+				return;
+			}
+		}
+		
+		// for the page class part
+		if(createPageClass.getSelection()){
+			if(!existsFolder(sourceFolder.getText())){
+				setMessage(MessageFormat.format(
+						ClickPlugin.getString("wizard.newPage.error.folderDoesNotExist"),
+						new String[]{ sourceFolder.getText() }), ERROR);
+				setPageComplete(false);
+				return;
+			} else if(!isValidPackageName(packageName.getText())){
+				setMessage(MessageFormat.format(
+						ClickPlugin.getString("wizard.newPage.error.packageIsInvalid1"), 
+						new Object[]{ packageName.getText() }), ERROR);
+				setPageComplete(false);
+				return;
+			} else if(packageName.getText().endsWith(".")){
+				setMessage(ClickPlugin.getString("wizard.newPage.error.packageIsInvalid2"), ERROR);
+				setPageComplete(false);
+				return;
+			} else if(className.getText().equals("")){
+				setMessage(ClickPlugin.getString("wizard.newPage.error.typeIsEmpty"), ERROR);
+				setPageComplete(false);
+				return;
+			} else if(!isValidTypeName(className.getText())){
+				setMessage(MessageFormat.format(
+						ClickPlugin.getString("wizard.newPage.error.typeIsInvalid"), 
+						new Object[]{ className.getText() }), ERROR);
+				setPageComplete(false);
+				return;
+			} else if(existsClass(sourceFolder.getText(), packageName.getText(), className.getText())){
+				setMessage(ClickPlugin.getString("wizard.newPage.error.typeAlreadyExists"), ERROR);
+				setPageComplete(false);
+				return;
+			} else if(packageName.getText().equals("")){
+				setMessage(ClickPlugin.getString("wizard.newPage.error.defaultPackage"), WARNING);
+				setPageComplete(true);
+				return;
+			}
+		}
+		
+		// all valid
+		setMessage(null);
+		setPageComplete(true);
+	}
+	
+	private boolean isValidPackageName(String packageName){
+		for(int i=0;i<packageName.length();i++){
+			char c = packageName.charAt(i);
+			if(i==0){
+				if(!Character.isJavaIdentifierStart(c)){
+					return false;
+				}
+			} else {
+				if(c=='.'){
+					continue;
+				} else if(!Character.isJavaIdentifierPart(c)){
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+	
+	private boolean isValidTypeName(String className){
+		for(int i=0;i<className.length();i++){
+			char c = className.charAt(i);
+			if(i==0){
+				if(!Character.isJavaIdentifierStart(c)){
+					return false;
+				}
+			} else {
+				if(!Character.isJavaIdentifierPart(c)){
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+	
+	private boolean existsFolder(String folder){
+		if(folder.equals("")){
+			return true; // TODO ??
+		}
+		
+		IProject project = getProject();
+		return project.getFolder(folder).exists();
+	}
+	
+	private boolean existsFile(String parentFolder, String fileName){
+		IProject project = getProject();
+		IFile file = null;
+		if(parentFolder.equals("")){
+			file = project.getFile(fileName);
+		} else {
+			file = project.getFolder(parentFolder).getFile(fileName);
+		}
+		return file.exists();
+	}
+	
+	private boolean existsClass(String sourceFolder, String packageName, String className){
+		try {
+			IProject project = getProject();
+			IResource resource = project.getProject();
+			if(!sourceFolder.equals("")){
+				resource = project.getFolder(sourceFolder);
+			}
+			
+			IJavaProject javaProject = JavaCore.create(project);
+			IPackageFragmentRoot root = javaProject.getPackageFragmentRoot(resource);
+			IPackageFragment fragment = root.getPackageFragment(packageName);
+			if(!fragment.exists()){
+				return false;
+			}
+			
+			ICompilationUnit unit = fragment.getCompilationUnit(className + ".java");
+			return unit.exists();
+			
+		} catch(Exception ex){
+			ex.printStackTrace();
+			return false;
+		}
+	}
+	
+	private GridData createGridData(int colspan){
+		GridData gd = new GridData();
+		gd.horizontalSpan = colspan;
+		return gd;
+	}
+	
+	private void selectProject(){
+		IWorkspaceRoot wsroot = ResourcesPlugin.getWorkspace().getRoot();
+		
+		// required validator
+		ISelectionStatusValidator validator = new ISelectionStatusValidator(){
+			private IStatus fgErrorStatus= new StatusInfo(IStatus.ERROR, ""); //$NON-NLS-1$
+			private IStatus fgOKStatus= new StatusInfo();
+			
+			public IStatus validate(Object[] selection){
+				if(selection==null || selection.length != 1){
+					return fgErrorStatus;
+				}
+				return fgOKStatus;
+			}
+		};
+		
+		// select only IJavaProject
+		ViewerFilter filter = new ViewerFilter(){
+		    public boolean select(Viewer viewer, Object parentElement, Object element){
+		    	try {
+			    	if(element instanceof IProject){
+			    		if(((IProject)element).hasNature(JavaCore.NATURE_ID)){
+			    			return true;
+			    		}
+			    	}
+		    	} catch(Exception ex){}
+		    	return false;
+		    }
+		};
+		
+		FolderSelectionDialog dialog = new FolderSelectionDialog(
+				getShell(), new WorkbenchLabelProvider(), new WorkbenchContentProvider());
+		
+		dialog.setTitle(ClickPlugin.getString("wizard.newPage.dialog.selectProject"));
+		
+		dialog.setInput(wsroot);
+		dialog.setValidator(validator);
+		dialog.addFilter(filter);
+		dialog.setInitialSelection(getProject());
+		if (dialog.open() == FolderSelectionDialog.OK) {
+			project.setText(((IProject)dialog.getFirstResult()).getName());
+		}
+	}
+	
+	private void selectFolder() {
+		try {
+			IProject currProject = getProject();
+			IWorkspaceRoot wsroot = ResourcesPlugin.getWorkspace().getRoot();
+			IResource init = null;
+			if(parentFolder.getText().length()!=0){
+				init = currProject.getFolder(parentFolder.getText());
+				if(!init.exists()){
+					init = null;
+				}
+			}
+			Class[] acceptedClasses = new Class[] { IProject.class, IFolder.class };
+			ISelectionStatusValidator validator = new TypedElementSelectionValidator(acceptedClasses, false);
+			IProject[] allProjects = wsroot.getProjects();
+			ArrayList rejectedElements = new ArrayList(allProjects.length);
+			for (int i = 0; i < allProjects.length; i++) {
+				if (!allProjects[i].equals(currProject)) {
+					rejectedElements.add(allProjects[i]);
+				}
+			}
+			ViewerFilter filter = new TypedViewerFilter(acceptedClasses, rejectedElements.toArray());
+			
+			FolderSelectionDialog dialog = new FolderSelectionDialog(
+					getShell(), new WorkbenchLabelProvider(), new WorkbenchContentProvider());
+			
+			dialog.setTitle(ClickPlugin.getString("wizard.newPage.dialog.selectFolder"));
+			//dialog.setMessage(HTMLPlugin.getResourceString("HTMLProjectPropertyPage.WebRoot"));
+			
+			dialog.setInput(wsroot);
+			dialog.setValidator(validator);
+			dialog.addFilter(filter);
+			dialog.setInitialSelection(init);
+			if (dialog.open() == FolderSelectionDialog.OK) {
+				parentFolder.setText(((IFolder)dialog.getFirstResult()).getProjectRelativePath().toString());
+			}
+			
+		} catch (Throwable t) {
+			ClickPlugin.log(t);
+		}
+	}
+	
+	private void selectSourceFolder() {
+		try {
+			Class[] acceptedClasses = new Class[] { IJavaModel.class, IJavaProject.class, IPackageFragmentRoot.class };
+			ISelectionStatusValidator validator = new TypedElementSelectionValidator(acceptedClasses, false);
+			
+			IPackageFragmentRoot init = null;
+			IJavaProject project = JavaCore.create(getProject());
+			
+			IPackageFragmentRoot[] roots = project.getPackageFragmentRoots();
+			ArrayList rejectedElements = new ArrayList();
+			for (int i = 0; i < roots.length; i++) {
+				if (roots[i] instanceof JarPackageFragmentRoot) {
+					rejectedElements.add(roots[i]);
+				} else if(roots[i] instanceof IPackageFragmentRoot){
+					if(((IPackageFragmentRoot)roots[i]).isArchive() || ((IPackageFragmentRoot)roots[i]).isExternal()){
+						rejectedElements.add(roots[i]);
+					} else {
+						if(roots[i].getResource().getProjectRelativePath().toString().equals(sourceFolder.getText())){
+							init = roots[i];
+						}
+					}
+				}
+			}
+			IJavaModel model = (IJavaModel)project.getParent();
+			IJavaProject[] projects = model.getJavaProjects();
+			for(int i=0;i<projects.length;i++){
+				if(!projects[i].equals(project)){
+					rejectedElements.add(projects[i]);
+				}
+			}
+			
+			ViewerFilter filter = new TypedViewerFilter(acceptedClasses, rejectedElements.toArray());
+			
+			FolderSelectionDialog dialog = new FolderSelectionDialog(
+					getShell(), new WorkbenchLabelProvider(), new WorkbenchContentProvider());
+			
+			dialog.setTitle(ClickPlugin.getString("wizard.newPage.dialog.selectSourceFolder"));
+			//dialog.setMessage(HTMLPlugin.getResourceString("HTMLProjectPropertyPage.WebRoot"));
+			
+			dialog.setInput(model);
+			dialog.setValidator(validator);
+			dialog.addFilter(filter);
+			dialog.setInitialSelection(init);
+			if (dialog.open() == FolderSelectionDialog.OK) {
+				sourceFolder.setText(((IPackageFragmentRoot)dialog.getFirstResult()).getElementName());
+			}
+			
+		} catch (Throwable t) {
+			ClickPlugin.log(t);
+		}
+	}
+	
+	/**
+	 * Returns the wizard should create a HTML file or not.
+	 * @return
+	 */
+	public boolean shouldCreateHTML(){
+		return createPageHTML.getSelection();
+	}
+	
+	/**
+	 * Returns the project relative path of the parent folder of the HTML file.
+	 * @return the project relative path of the parent folder
+	 */
+	public String getParentFolder(){
+		return parentFolder.getText();
+	}
+	
+	/**
+	 * Returns the HTML filename.
+	 * @return the HTML filename
+	 */
+	public String getFilename(){
+		return pageName.getText();
+	}
+	
+	public boolean shouldCreateClass(){
+		return createPageClass.getSelection();
+	}
+	
+	/**
+	 * Returns the project relative path of the source folder of the page class.
+	 * @return the project relative path of the source folder
+	 */
+	public String getSourceFolder(){
+		return sourceFolder.getText();
+	}
+	
+	/**
+	 * Returns the package name of the page class.
+	 * @return the package name
+	 */
+	public String getPackageName(){
+		return packageName.getText();
+	}
+	
+	/**
+	 * Returns the class name of the page class.
+	 * @return the class name
+	 */
+	public String getClassName(){
+		return className.getText();
+	}
+	
+	/**
+	 * Returns the wizard should add the page mapping to click.xml or not.
+	 * @return
+	 */
+	public boolean shouldAddToClickXML(){
+		return addToClickXML.getSelection();
+	}
+	
+	public String getSuperClass(){
+		return superClass.getText();
+	}
+	
+	public Template getTemplate(){
+		return (Template)templates.get(template.getSelectionIndex());
+	}
+	
+	public IProject getProject(){
+		try {
+			IWorkspaceRoot wsroot = ResourcesPlugin.getWorkspace().getRoot();
+			IProject project = wsroot.getProject(this.project.getText());
+			if(project.hasNature(JavaCore.NATURE_ID)){
+				return project;
+			}
+		} catch(Exception ex){
+		}
+		return null;
+	}
+
+}
diff --git a/org.apache.click.eclipse/toc.xml b/org.apache.click.eclipse/toc.xml
new file mode 100644
index 0000000..28c120f
--- /dev/null
+++ b/org.apache.click.eclipse/toc.xml
@@ -0,0 +1,38 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one
+ or more contributor license agreements.  See the NOTICE file
+ distributed with this work for additional information
+ regarding copyright ownership.  The ASF licenses this file
+ to you under the Apache License, Version 2.0 (the
+ "License"); you may not use this file except in compliance
+ with the License.  You may obtain a copy of the License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing,
+ software distributed under the License is distributed on an
+ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ KIND, either express or implied.  See the License for the
+ specific language governing permissions and limitations
+ under the License.
+-->
+<toc label="Apache Click">
+  <topic label="Click User Guide" href="documentation/user-guide/index.html">
+    <topic label="Introduction to Click" href="documentation/user-guide/ch01.html"/>
+    <topic label="Pages" href="documentation/user-guide/ch02.html"/>
+    <topic label="Controls" href="documentation/user-guide/ch03.html"/>
+    <topic label="Configuration" href="documentation/user-guide/ch04.html"/>
+    <topic label="Best Practices" href="documentation/user-guide/ch05.html"/>
+  </topic>
+  <topic label="Javadoc" href="documentation/javadoc.html">
+    <topic label="Click API" href="http://incubator.apache.org/click/docs/click-api/overview-summary.html"/>
+    <topic label="Control API" href="http://incubator.apache.org/click/docs/click-api/org/apache/click/control/package-summary.html"/>
+    <topic label="Extras API" href="http://incubator.apache.org/click/docs/extras-api/overview-summary.html"/>
+    <topic label="Mock API" href="http://incubator.apache.org/click/docs/mock-api/overview-summary.html"/>
+  </topic>
+  <topic label="Velocity" href="documentation/velocity/velocity.html">
+    <topic label="Users Guide PDF" href="documentation/velocity/VelocityUsersGuide.pdf"/>
+    <topic label="Developers Guide" href="documentation/velocity/developer-guide.html"/>
+    <topic label="VTL Reference" href="documentation/velocity/vtl-reference-guide.html"/>
+  </topic>
+</toc>
