You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@wicket.apache.org by da...@apache.org on 2016/11/18 15:15:45 UTC
[03/22] wicket git commit: Removes gdoc infrastructure,
adds asciidoctor files
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_2.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_2.adoc b/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_2.adoc
new file mode 100644
index 0000000..b23535f
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_2.adoc
@@ -0,0 +1,145 @@
+
+
+
+Stateful pages are versioned in order to support browser's back button: when this button is pressed Wicket must respond by rendering the same page instance previously used.
+
+A new page version is created when a stateful page is requested for the first time or when an existing instance is modified (for example changing its component hierarchy). To identify each page version Wicket uses a session-relative identifier called page id. This is a unique number and it is increased every time a new page version is created.
+
+In the final example of the previous chapter (project LifeCycleStages), you may have noticed the number appended at the end of URL. This number is the page id we are talking about:
+
+image::../img/page-id.png[]
+
+In this chapter we will use a revised version of this example project where the component hierarchy is modified inside the Link's onClick()method. This is necessary because Wicket creates a new page version only if the page is modified before its method onBeforeRender() is invoked. The code of the new home page is the following:
+
+[source,java]
+----
+public class HomePage extends WebPage
+{
+ private static final long serialVersionUID = 1L;
+ private Label firstLabel;
+ private Label secondLabel;
+
+ public HomePage(){
+ firstLabel = new Label("label", "First label");
+ secondLabel = new Label("label", "Second label");
+
+ add(firstLabel);
+
+ add(new Link("reload"){
+ @Override
+ public void onClick() {
+ if(getPage().contains(firstLabel, true))
+ getPage().replace(secondLabel);
+ else
+ getPage().replace(firstLabel);
+ }
+ });
+
+ }
+}
+----
+
+Now if we run the new example (project LifeCycleStagesRevisited) and we click on the \u201cReload\u201d button, a new page version is created and the page id is increased by one:
+
+image::../img/reload-page.png[]
+
+If we press the back button the page version previously rendered (and serialized) will be retrieved (i.e. deserialized) and it will be used again to respond to our request (and page id is decremented):
+
+image::../img/browser-back.png[]
+
+NOTE: For more details about page storing you can take a look at paragraph [Page storing] from chapter [Wicket Internals] The content of this paragraph is from wiki page https://cwiki.apache.org/confluence/display/WICKET/Page+Storage.
+
+As we have stated at the beginning of this chapter, page versions are stored using Java serialization, therefore every object referenced inside a page must be serializable. In <<modelsforms.adoc#_model_chaining,paragraph 11.6>> we will see how to overcome this limit and work with non-serializable objects in our components using detachable Wicket models.
+
+=== Using a specific page version with PageReference
+
+To retrieve a specific page version in our code we can use class _org.apache.wicket.PageReference_ by providing its constructor with the corresponding page id:
+
+[source,java]
+----
+//load page version with page id = 3
+PageReference pageReference = new PageReference(3);
+//load the related page instance
+Page page = pageReference.getPage();
+----
+
+To get the related page instance we must use the method getPage.
+
+=== Turning off page versioning
+
+If for any reason we need to switch off versioning for a given page, we can call its method setVersioned(false).
+
+=== Pluggable serialization
+
+Starting from version 1.5 it is possible to choose which implementation of Java serialization will be used by Wicket to store page versions. Wicket serializes pages using an implementation of interface _org.apache.wicket.serialize.ISerializer_. The default implementation is _org.apache.wicket.serialize.java.JavaSerializer_ and it uses the standard Java serialization mechanism based on classes ObjectOutputStream and ObjectInputStream. However on Internet we can find other interesting serialization libraries like https://github.com/EsotericSoftware/kryo[Kryo]
+
+We can access this class inside the method _init_ of the class Application using the getFrameworkSettings() method :
+
+[source,java]
+----
+@Override
+public void init()
+{
+ super.init();
+ getFrameworkSettings().setSerializer(yourSerializer);
+}
+----
+
+A serializer based on Kryo library and another one based on Fast are provided by the WicketStuff project. You can find more information on this project, as well as the instructions to use its modules, in Appendix B.
+
+=== Page caching
+
+By default Wicket persists versions of pages into a session-relative file on disk, but it uses a two-levels cache to speed up this process. The first level of the cache uses a http session attribute called \u201cwicket:persistentPageManagerData-<APPLICATION_NAME>\u201d to store pages. The second level cache stores pages into application-scoped variables which are identified by a session id and a page id.
+
+The following picture is an overview of these two caching levels:
+
+image::../img/wicket-cache.png[]
+
+The session-scoped cache is faster then the other memory levels but it contains only the pages used to serve the last request. Wicket allows us to set the maximum amount of memory allowed for the application-scoped cache and for the page store file. Both parameters can be configured via setting class _org.apache.wicket.settings.StoreSettings_.
+
+This interface provides the setMaxSizePerSession(Bytes bytes) method to set the size for page store file. The Bytes parameter is the maximum size allowed for this file:
+
+[source,java]
+----
+@Override
+public void init()
+{
+ super.init();
+ getStoreSettings().setMaxSizePerSession(Bytes.kilobytes(500));
+}
+----
+
+Class _org.apache.wicket.util.lang.Bytes_ is an utility class provided by Wicket to express size in bytes (for further details refer to the JavaDoc).
+For the second level cache we can use the setInmemoryCacheSize(int inmemoryCacheSize) method. The integer parameter is the maximum number of page instances that will be saved into application-scoped cache:
+
+[source,java]
+----
+@Override
+public void init()
+{
+ super.init();
+ getStoreSettings().setInmemoryCacheSize(50);
+}
+----
+
+=== Page expiration
+
+Page instances are not kept in the user session forever. They can be discarded when the limit set with the setMaxSizePerSession method is reached or (more often) when user session expires. When we ask Wicket for a page id corresponding to a page instance removed from the session, we bump into a PageExpiredException and we get the following default error page:
+
+image::../img/page-expired.png[]
+
+This error page can be customized with the _setPageExpiredErrorPage_ method of class _org.apache.wicket.settings.ApplicationSettings_:
+
+[source,java]
+----
+@Override
+public void init()
+{
+ super.init();
+ getApplicationSettings().setPageExpiredErrorPage(
+ CustomExpiredErrorPage.class);
+}
+----
+
+The page class provided as custom error page must have a public constructor with no argument or a constructor that takes as input a single PageParameters argument (the page must be bookmarkable as described in <<urls.adoc#_pageparameters,paragraph 10.1.1>>).
+
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_3.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_3.adoc b/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_3.adoc
new file mode 100644
index 0000000..461d2bf
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_3.adoc
@@ -0,0 +1,48 @@
+
+
+
+Wicket makes it very easy to build stateful pages, but sometimes we might want to use an \u201cold school\u201d stateless page that doesn't keep memory of its state in the user session. For example consider the public area of a site or a login page: in those cases a stateful page would be a waste of resources or even a security threat, as we will see in paragraph [paragraph 12.10|guide:forms2_10].
+
+In Wicket a page can be stateless only if it satisfies the following requirements:
+
+1. it has been instantiated by Wicket (i.e. we don't create it with operator new) using a constructor with no argument or a constructor that takes as input a single PageParameters argument (class PageParameters will be covered in <<urls.adoc#_pageparameters,chapter 10.1>>).
+2. All its children components (and behaviors) are in turn stateless, which means that their method isStateless must return true.
+
+The first requirement implies that, rather than creating a page by hand, we should rely on Wicket's capability of resolving page instances, like we do when we use method setResponsePage(Class page).
+
+In order to comply with the second requirement it could be helpful to check if all children components of a page are stateless. To do this we can leverage method visitChildren and the visitor pattern to iterate over components and test if their method isStateless actually returns true:
+
+[source,java]
+----
+@Override
+protected void onInitialize() {
+ super.onInitialize();
+
+ visitChildren(new IVisitor<Component, Void>() {
+ @Override
+ public void component(Component component, IVisit<Void> arg1) {
+ if(!component.isStateless())
+ System.out.println("Component " + component.getId() + " is not stateless");
+ }
+ });
+ }
+----
+
+Alternatively, we could use the _StatelessComponent_ utility annotation along with the _StatelessChecker_ class (they are both in package _org.apache.wicket.devutils.stateless_). _StatelessChecker_ will throw an _IllegalArgumentException_ if a component annotated with _StatelessComponent_ doesn't respect the requirements for being stateless. To use _StatelessComponent_ annotation we must first add the _StatelessChecker_ to our application as a component render listener:
+
+[source,java]
+----
+@Override
+public void init()
+{
+ super.init();
+ getComponentPostOnBeforeRenderListeners().add(new StatelessChecker());
+}
+----
+
+NOTE: Most of the Wicket's built-in components are stateful, hence they can not be used with a stateless page. However some of them have also a stateless version which can be adopted when we need to keep a page stateless. In the rest of the guide we will point out when a built-in component comes also with a stateless version.
+
+A page can be also explicitly declared as stateless setting the appropriate flag to true with the setStatelessHint(true) method. This method will not prevent us from violating the requirements for a stateless page, but if we do so we will get the following warning log message:
+
+WARNING: Page '<page class>' is not stateless because of component with path '<component path>'
+
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_4.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_4.adoc b/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_4.adoc
new file mode 100644
index 0000000..a1ebdd2
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/versioningCaching/versioningCaching_4.adoc
@@ -0,0 +1,8 @@
+
+
+
+In this chapter we have seen how page instances are managed by Wicket. We have learnt that pages can be divided into two families: stateless and stateful pages. Knowing the difference between the two types of pages is important to build the right page for a given task.
+
+However, to complete the discussion about stateless pages we still have to deal with two topics we have just outlined in this chapter: class PageParameters and bookmarkable pages. The first part of
+<<_wicket_links_and_url_generation,chapter 10>> will cover these missing topics.
+
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/whyLearn.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/whyLearn.adoc b/wicket-user-guide/src/main/asciidoc/whyLearn.adoc
new file mode 100644
index 0000000..a987b67
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/whyLearn.adoc
@@ -0,0 +1,7 @@
+
+Software development is a challenging activity and developers must keep their skills up-to-date with new technologies.
+
+But before starting to learn the last \u201ccoolest\u201d framework we should always ask ourself if it is the right tool for us and how it can improve our everyday job.
+Java's ecosystem is already full of many well-known web frameworks, so why should we spend our time learning Wicket?
+
+This chapter will show you how Wicket is different from other web frameworks you may know and it will explain also how it can improve your life as web developer.
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_1.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_1.adoc b/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_1.adoc
new file mode 100644
index 0000000..1922670
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_1.adoc
@@ -0,0 +1,11 @@
+
+...but we all hate spaghetti code! That's why in the first half of the 2000s we have seen the birth of so many web frameworks. Their mission was to separate our business code from presentation layer (like JSP pages).
+
+Some of theme (like Struts, Spring MVC, Velocity, etc...) have become widely adopted and they made the MVC pattern very popular among developers.
+However, none of these frameworks offers a real object-oriented (OO) abstraction for web pages and we still have to take care of web-related tasks such as HTTP request/response handling, URLs mapping, storing data into user session and so on.
+
+The biggest limit of MVC frameworks is that they don't do much to overcome the impedance mismatch between the stateless nature of HTTP protocol and the need of our web applications of handling a (very complex) state.
+
+To overcome these limits developers have started to adopt a new generation of component oriented web frameworks designed to provide a completely different approach to web development.
+
+
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_2.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_2.adoc b/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_2.adoc
new file mode 100644
index 0000000..b1d2bd2
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_2.adoc
@@ -0,0 +1,16 @@
+
+Component oriented frameworks differ from classic web frameworks in that they build a model of requested page on the server side and the HTML sent back to the client is generated according to this model. You can think of the model as if it was an \u201cinverse\u201d JavaScript DOM, meaning that:
+
+1. is built on server-side
+2. is built before HTML is sent to client
+3. HTML code is generated using this model and not vice versa.
+
+ image::../img/requesthandling-general.png[]
+
+ _General schema of page request handling for a component oriented framework_
+
+With this kind of framework our web pages and their HTML components (forms, input controls, links, etc...), are pure class instances.
+Since pages are class instances they live inside the JVM heap and we can handle them as we do with any other Java class.
+This approach is very similar to what GUI frameworks (like Swing or SWT) do with desktop windows and their components. Wicket and the other component oriented frameworks bring to web development the same kind of abstraction that GUI frameworks offer when we build a desktop application. Most of those kind of frameworks hide the details of the HTTP protocol and naturally solve the problem of its stateless nature.
+
+
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_3.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_3.adoc b/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_3.adoc
new file mode 100644
index 0000000..5e69458
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_3.adoc
@@ -0,0 +1,10 @@
+
+At this point some people may still wonder why OOP is so important also for web development and what benefits it can bring to developers.
+Let's quickly review the main advantages that this paradigm can offer us:
+
+* *Web pages are objects*: web pages are not just text files sent back to the client. They are object instances and we can harness OOP to design web pages and their components. With Wicket we can also apply inheritance to HTML markup in order to build a consistent graphic layout for our applications (we will see markup inheritance in <<layout.adoc#_here_comes_the_inheritance,chapter 4.2>>).
+* *We don't have to worry about application's state*: pages and components can be considered stateful entities. They are Java objects and they can keep a state inside them and reference other objects. We can stop worrying about keeping track of user data stored inside the _HttpSession_ and we can start managing them in a natural and transparent way.
+* *Testing web applications is much easier*: since pages and components are pure objects, you can use JUnit to test their behavior and to ensure that they render as expected. Wicket has a set of utility classes for unit testing that simulate user interaction with web pages, hence we can write acceptance tests using just JUnit without any other test framework (unit testing is covered in
+<<_test_driven_development_with_wicket,chapter 23>>).
+
+
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_4.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_4.adoc b/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_4.adoc
new file mode 100644
index 0000000..e27362b
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/whyLearn/whyLearn_4.adoc
@@ -0,0 +1,13 @@
+
+Wicket is not the only component oriented framework available in the Java ecosystem. Among its competitors we can find GWT (from Google), JSF (from Oracle), Vaadin (from Vaadin Ltd.), etc... Even if Wicket and all those other frameworks have their pros and cons, there are good reasons to prefer Wicket over them:
+
+* *Wicket is 100% open source*: Wicket is a top Apache project and it doesn't depend on any private company. You don't have to worry about future licensing changes, Wicket will always be released under Apache license 2.0 and freely available.
+
+* *Wicket is a community driven project*: The Wicket team supports and promotes the dialogue with the framework's users through two mailing lists http://wicket.apache.org/help/email.html[(one for users and another one for framework developers)] and an https://issues.apache.org/jira/browse/WICKET[Apache JIRA] (the issue tracking system). Moreover, as any other Apache project, Wicket is developed paying great attention to user feedbacks and to suggested features.
+
+* *Wicket is just about Java and good old HTML*: almost all web frameworks force users to adopt special tags or to use server side code inside HTML markup. This is clearly in contrast with the concept of separation between presentation and business logic and it leads to a more confusing code in our pages. In Wicket we don't have to take care of generating HTML inside the page itself, and we won't need to use any tag other than standard HTML tags. All we have to do is to attach our components (Java instances) to the HTML tags using a simple tag attribute called _wicket:id_ (we will shortly see how to use it).
+
+* *With Wicket we can easily use JavaBeans and http://en.wikipedia.org/wiki/Plain_Old_Java_Object[POJO] in our web tier*: one of the most annoying and error-prone task in web development is collecting user input through a form and keeping form fields updated with previously inserted values. This usually requires a huge amount of code to extract input from request parameters (which are strings), parse them to Java types and store them into some kind of variable. And this is just half of the work we have to do as we must implement the inverse path (load data from Java to the web form).Moreover, most of the times our forms will use a JavaBean or a POJO as backing object, meaning that we must manually map form fields with the corresponding object fields and vice versa. Wicket comes with an intuitive and flexible mechanism that does this mapping for us without any configuration overhead (using a convention over configuration approach) and in a transparent way.
+<<_wicket_models_and_forms,Chapter 10>> will introduce the concept of Wicket model and we will learn how to harness this entity with forms.
+
+* *No complex XML needed*: Wicket was designed to minimize the amount of configuration files needed to run our applications. No XML file is required except for the standard deployment descriptor web.xml (unless you are using Servlet 3 or a later version. See <<whyLearn.adoc#_component_oriented_frameworks_an_overview,Chapter 4>> for more details).
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/wicketstuff.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/wicketstuff.adoc b/wicket-user-guide/src/main/asciidoc/wicketstuff.adoc
new file mode 100644
index 0000000..139597f
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/wicketstuff.adoc
@@ -0,0 +1,2 @@
+
+
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_1.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_1.adoc b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_1.adoc
new file mode 100644
index 0000000..6d3633d
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_1.adoc
@@ -0,0 +1,20 @@
+
+
+
+WicketStuff is an umbrella project that gathers different Wicket-related projects developed and maintained by the community. The project is hosted on GitHub at https://github.com/wicketstuff/core[https://github.com/wicketstuff/core] .
+Every module is structured as a parent Maven project containing the actual project that implements the new functionality and an example project that illustrates how to use it in our code. The resulting directory structure of each module is the following:
+
+[source,java]
+----
+\<module name>-parent
+ |
+ +---<module name>
+ \---<module name>-examples
+----
+
+So far we have introduced only modules Kryo Serializer and JavaEE Inject, but WicketStuff comes with many other modules that can be used in our applications. Some of them come in handy to improve the user experience of our pages with complex components or integrating some popular web services (like http://maps.google.com/[Google Maps] ) and JavaScript libraries (like http://www.tinymce.com/[TinyMCE] ).
+
+This appendix provides a quick overview of what WicketStuff offers to enhance the usability and the visually-appealing of our pages.
+
+NOTE: Every WicketStuff module can be downloaded as JAR archive at http://mvnrepository.com[http://mvnrepository.com] . This site provides also the XML fragment needed to include it as a dependency into our pom.xml file.
+
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_2.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_2.adoc b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_2.adoc
new file mode 100644
index 0000000..eef717c
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_2.adoc
@@ -0,0 +1,50 @@
+
+
+
+Module tinymce offers integration with the namesake JavaScript library that turns our \u201chumble\u201d text-areas into a full-featured HTML WYSIWYG editor:
+
+image::../img/tinymce.png[]
+
+To \u201ctinyfy\u201d a textarea component we must use behavior TinyMceBehavior:
+
+[source,java]
+----
+TextArea textArea = new TextArea("textArea", new Model(""));
+textArea.add(new TinyMceBehavior());
+----
+
+By default TinyMceBehavior adds only a basic set of functionalities to our textarea:
+
+image::../img/tinymce_basic.png[]
+
+To add more functionalities we must use class TinyMCESettings to register additional TinyMCE plugins and to customize the toolbars buttons. The following code is an excerpt from example page FullFeaturedTinyMCEPage:
+
+[source,java]
+----
+TinyMCESettings settings = new TinyMCESettings(
+ TinyMCESettings.Theme.advanced);
+//...
+// first toolbar
+//...
+settings.add(Button.newdocument, TinyMCESettings.Toolbar.first,
+ TinyMCESettings.Position.before);
+settings.add(Button.separator, TinyMCESettings.Toolbar.first,
+ TinyMCESettings.Position.before);
+settings.add(Button.fontselect, TinyMCESettings.Toolbar.first,
+ TinyMCESettings.Position.after);
+//...
+// other settings
+settings.setToolbarAlign(
+ TinyMCESettings.Align.left);
+settings.setToolbarLocation(
+ TinyMCESettings.Location.top);
+settings.setStatusbarLocation(
+ TinyMCESettings.Location.bottom);
+settings.setResizing(true);
+//...
+TextArea textArea = new TextArea("ta", new Model(TEXT));
+textArea.add(new TinyMceBehavior(settings));
+----
+
+For more configuration examples see pages inside package wicket.contrib.examples.tinymce in the example project of the module.
+
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_3.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_3.adoc b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_3.adoc
new file mode 100644
index 0000000..a138b58
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_3.adoc
@@ -0,0 +1,35 @@
+
+
+
+Module wicketstuff-gmap3 integrates http://maps.google.com[Google Maps] service with Wicket providing component org.wicketstuff.gmap.GMap. If we want to embed Google Maps into one of our pages we just need to add component GMap inside the page. The following snippet is taken from example page SimplePage:
+
+*HTML:*
+
+[source,html]
+----
+...
+<body>
+ <div wicket:id="map">Map</div>
+</body>
+...
+----
+
+*Java code:*
+
+[source,java]
+----
+public class SimplePage extends WicketExamplePage
+{
+ public SimplePage()
+ {
+ GMap map = new GMap("map");
+ map.setStreetViewControlEnabled(false);
+ map.setScaleControlEnabled(true);
+ map.setScrollWheelZoomEnabled(true);
+ map.setCenter(new GLatLng(52.47649, 13.228573));
+ add(map);
+ }
+}
+----
+
+The component defines a number of setters to customize its behavior and appearance. More info can be found on wiki page https://github.com/wicketstuff/core/wiki/Gmap3[https://github.com/wicketstuff/core/wiki/Gmap3] .
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_4.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_4.adoc b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_4.adoc
new file mode 100644
index 0000000..9ac116f
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_4.adoc
@@ -0,0 +1,35 @@
+
+
+
+To integrate the https://developers.google.com/chart/[Google Chart] tool into our pages we can use module wicketstuff-googlecharts. To display a chart we must combine the following entities: component Chart, interface IChartData and class ChartProvider, all inside package org.wicketstuff.googlecharts. The following snippet is taken from example page Home:
+
+*HTML:*
+
+[source,html]
+----
+...
+ <h2>Hello World</h2>
+ <img wicket:id="helloWorld"/>
+...
+----
+
+*Java code:*
+
+[source,java]
+----
+IChartData data = new AbstractChartData(){
+ public double[][] getData(){
+ return new double[][] { { 34, 22 } };
+ }
+};
+
+ChartProvider provider = new ChartProvider(new Dimension(250, 100), ChartType.PIE_3D, data);
+provider.setPieLabels(new String[] { "Hello", "World" });
+add(new Chart("helloWorld", provider));
+----
+
+*Displayed chart:*
+
+image::../img/googlechart.png[]
+
+As we can see in the snippet above, component Chart must be used with <img> tag while the input data returned by IChartData must be a two-dimensional array of double values.
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_5.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_5.adoc b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_5.adoc
new file mode 100644
index 0000000..37d889f
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_5.adoc
@@ -0,0 +1,44 @@
+
+
+
+Module wicketstuff-inmethod-grid implements a sophisticated grid-component with class com. inmethod.grid.datagrid.DataGrid.
+
+Just like pageable repeaters (seen in <<repeaters.adoc#_pageable_repeaters,paragraph 13.4>>) DataGrid provides data pagination and uses interface IDataProvider as data source. In addition the component is completely ajaxified:
+
+image::../img/inmethod-grid1.png[]
+
+DataGrid supports also editable cells and row selection:
+
+image::../img/inmethod-grid2.png[]
+
+The following snippet illustrate how to use DataGrid and is taken from wiki page https://github.com/wicketstuff/core/wiki/InMethodGrid[https://github.com/wicketstuff/core/wiki/InMethodGrid] :
+
+*HTML:*
+
+[source,html]
+----
+...
+ <div wicket:id="grid">Grid</div>
+...
+----
+
+*Java code:*
+
+[source,java]
+----
+final List<Person> personList = //load a list of Persons
+final ListDataProvider listDataProvider = new ListDataProvider(personList);
+//define grid's columns
+List<IGridColumn> cols = (List) Arrays.asList(
+ new PropertyColumn(new Model("First Name"), "firstName"),
+ new PropertyColumn(new Model("Last Name"), "lastName"));
+
+DataGrid grid = new DefaultDataGrid("grid", new DataProviderAdapter(listDataProvider), cols);
+add(grid);
+----
+
+In the code above we have used convenience class DefaultDataGrid that is a subclass of DataGrid and it already comes with a navigation toolbar.
+
+The example pages are under package com.inmethod.grid.examples.pages in the example project which is hosted at http://www.wicket-library.com/inmethod-grid/data-grid/simple[http://www.wicket-library.com/inmethod-grid/data-grid/simple] .
+
+
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_6.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_6.adoc b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_6.adoc
new file mode 100644
index 0000000..0a834df
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_6.adoc
@@ -0,0 +1,82 @@
+
+REST-based API are becoming more and more popular around the web and the number of services based on this architecture is constantly increasing.
+
+Wicket is well-known for its capability of transparently handling the state of web applications on server side, but it can be also easily adopted to create RESTful services.
+WicketStuff module for REST provides a special resource class and a set of annotations to implement REST APIs/services in much the same way as we do it with Spring MVC or with the standard JAX-RS.
+
+The module provides class _AbstractRestResource_ as generic abstract class to implement a Wicket resource that handles the request and the response using a particular data format (XML, JSON, etc...).
+Subclassing _AbstractRestResource_ we can create custom resources and map their pubblic methods to a given subpath with annotation _MethodMapping_. The following snippet is taken from resource _PersonsRestResource_ inside module _'restannotations-examples'_:
+
+[source,java]
+----
+ @MethodMapping("/persons")
+ public List<PersonPojo> getAllPersons() {
+ //method mapped at subpath "/persons" and HTTP method GET
+ }
+
+ @MethodMapping(value = "/persons/{personIndex}", httpMethod = HttpMethod.DELETE)
+ public void deletePerson(int personIndex) {
+ //method mapped at subpath "/persons/{personIndex}" and HTTP method DELETE.
+ //Segment {personIndex} will contain an integer value as index.
+ }
+
+ @MethodMapping(value = "/persons", httpMethod = HttpMethod.POST)
+ public void createPerson(@RequestBody PersonPojo personPojo) {
+ //creates a new instance of PersonPojo reading it from request body
+ }
+----
+
+_MethodMapping_ requires to specify the subpath we want to map the method to. In addition we can specify also the HTTP method that must be used to invoke the method via REST (GET, POST, DELETE, PATCH, etc...). This value can be specified with enum class _HttpMethod_ and is GET by default.
+In the code above we can see annotation _RequestBody_ which is used to extract the value of a method parameter from the request body (method createPerson).
+To write/read objects to response/from request, _AbstractRestResource_ uses an implementation of interface _IWebSerialDeserial_ which defines the following methods:
+
+[source,java]
+----
+
+ public interface IWebSerialDeserial {
+
+ public void objectToResponse(Object targetObject, WebResponse response, String mimeType) throws Exception;
+
+ public <T> T requestToObject(WebRequest request, Class<T> argClass, String mimeType) throws Exception;
+
+ public boolean isMimeTypeSupported(String mimeType);
+ }
+----
+
+To convert segments value (which are strings) to parameters type, _AbstractRestResource_ uses the standard Wicket mechanism based on the application converter locator:
+
+[source,java]
+----
+
+ //return the converter for type clazz
+ IConverter converter = Application.get().getConverterLocator().getConverter(clazz);
+ //convert string to object
+ return converter.convertToObject(value, Session.get().getLocale());
+----
+
+In order to promote the principle of convention over configuration, we don't need to use any annotation to map method parameters to path parameters if they are declared in the same order. If we need to manually bind method parameters to path parameters we can use annotation _PathParam_.
+
+[source,java]
+----
+ @MethodMapping(value = "/variable/{p1}/order/{p2}", produces = RestMimeTypes.PLAIN_TEXT)
+ public String testParamOutOfOrder(@PathParam("p2") String textParam, @PathParam("p1") int intParam) {
+ //method parameter textParam is taken from path param 'p2', while intParam uses 'p1'
+ }
+----
+
+As JSON is de-facto standard format for REST API, the project comes also with a ready-to-use resource (_GsonRestResource_) and a serial/deserial (_GsonSerialDeserial_) that work with JSON format (both inside module _'restannotations-json'_). These classes use Gson as JSON library.
+
+_AbstractRestResource_ supports role-based authorizations for mapped method with annotation _AuthorizeInvocation_:
+
+[source,java]
+----
+ @MethodMapping(value = "/admin", httpMethod = HttpMethod.GET)
+ @AuthorizeInvocation("ROLE_ADMIN")
+ public void testMethodAdminAuth() {
+
+ }
+----
+
+To use annotation _AuthorizeInvocation_ we must specify in the resource construcor an instance of Wicket interface _IRoleCheckingStrategy_.
+
+To read the complete documentation of the module and to discover more advanced feature please refer to the https://github.com/wicketstuff/core/tree/master/wicketstuff-restannotations-parent[project homepage]
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_7.adoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_7.adoc b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_7.adoc
new file mode 100644
index 0000000..fe08dd5
--- /dev/null
+++ b/wicket-user-guide/src/main/asciidoc/wicketstuff/wicketstuff_7.adoc
@@ -0,0 +1,6 @@
+
+Wicket makes working with AJAX easy and pleasant with its component-oriented abstraction. However as side effect, AJAX components and behaviors make their hosting page stateful. This can be quite annoying if we are working on a page that must be stateless (for example a login page).
+In this case an obvious solution would be to roll out our own stateless components/behaviors, but Wicketstuff alredy offers such kind of artifacts with _stateless_ module. Here you can find the stateless version of the basic AJAX componets and behaviors shiped with Wicket, like _StatelessAjaxSubmitLink_, _StatelessAjaxFallbackLink_, _StatelessAjaxEventBehavior_, _StatelessAjaxFormSubmitBehavior_ etc...
+A short introduction to this module can be found on its https://github.com/wicketstuff/core/tree/master/stateless-parent[home page] .
+
+
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/web-app/WEB-INF/applicationContext.xml
----------------------------------------------------------------------
diff --git a/wicket-user-guide/web-app/WEB-INF/applicationContext.xml b/wicket-user-guide/web-app/WEB-INF/applicationContext.xml
deleted file mode 100644
index 69fbef3..0000000
--- a/wicket-user-guide/web-app/WEB-INF/applicationContext.xml
+++ /dev/null
@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<beans xmlns="http://www.springframework.org/schema/beans"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="
-http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
-
- <bean id="grailsApplication" class="org.codehaus.groovy.grails.commons.GrailsApplicationFactoryBean">
- <description>Grails application factory bean</description>
- <property name="grailsDescriptor" value="/WEB-INF/grails.xml" />
- <property name="grailsResourceLoader" ref="grailsResourceLoader" />
- </bean>
-
- <bean id="pluginManager" class="org.codehaus.groovy.grails.plugins.GrailsPluginManagerFactoryBean">
- <description>A bean that manages Grails plugins</description>
- <property name="grailsDescriptor" value="/WEB-INF/grails.xml" />
- <property name="application" ref="grailsApplication" />
- </bean>
-
- <bean id="grailsConfigurator" class="org.codehaus.groovy.grails.commons.spring.GrailsRuntimeConfigurator">
- <constructor-arg>
- <ref bean="grailsApplication" />
- </constructor-arg>
- <property name="pluginManager" ref="pluginManager" />
- </bean>
-
- <bean id="grailsResourceLoader" class="org.codehaus.groovy.grails.commons.GrailsResourceLoaderFactoryBean" />
-
- <bean id="characterEncodingFilter" class="org.springframework.web.filter.CharacterEncodingFilter">
- <property name="encoding">
- <value>utf-8</value>
- </property>
- </bean>
-</beans>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/web-app/WEB-INF/sitemesh.xml
----------------------------------------------------------------------
diff --git a/wicket-user-guide/web-app/WEB-INF/sitemesh.xml b/wicket-user-guide/web-app/WEB-INF/sitemesh.xml
deleted file mode 100644
index 72399ce..0000000
--- a/wicket-user-guide/web-app/WEB-INF/sitemesh.xml
+++ /dev/null
@@ -1,14 +0,0 @@
-<sitemesh>
- <page-parsers>
- <parser content-type="text/html"
- class="org.codehaus.groovy.grails.web.sitemesh.GrailsHTMLPageParser" />
- <parser content-type="text/html;charset=ISO-8859-1"
- class="org.codehaus.groovy.grails.web.sitemesh.GrailsHTMLPageParser" />
- <parser content-type="text/html;charset=UTF-8"
- class="org.codehaus.groovy.grails.web.sitemesh.GrailsHTMLPageParser" />
- </page-parsers>
-
- <decorator-mappers>
- <mapper class="org.codehaus.groovy.grails.web.sitemesh.GrailsLayoutDecoratorMapper" />
- </decorator-mappers>
-</sitemesh>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/web-app/WEB-INF/tld/c.tld
----------------------------------------------------------------------
diff --git a/wicket-user-guide/web-app/WEB-INF/tld/c.tld b/wicket-user-guide/web-app/WEB-INF/tld/c.tld
deleted file mode 100644
index 5e18236..0000000
--- a/wicket-user-guide/web-app/WEB-INF/tld/c.tld
+++ /dev/null
@@ -1,572 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-
-<taglib xmlns="http://java.sun.com/xml/ns/javaee"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
- version="2.1">
-
- <description>JSTL 1.2 core library</description>
- <display-name>JSTL core</display-name>
- <tlib-version>1.2</tlib-version>
- <short-name>c</short-name>
- <uri>http://java.sun.com/jsp/jstl/core</uri>
-
- <validator>
- <description>
- Provides core validation features for JSTL tags.
- </description>
- <validator-class>
- org.apache.taglibs.standard.tlv.JstlCoreTLV
- </validator-class>
- </validator>
-
- <tag>
- <description>
- Catches any Throwable that occurs in its body and optionally
- exposes it.
- </description>
- <name>catch</name>
- <tag-class>org.apache.taglibs.standard.tag.common.core.CatchTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-Name of the exported scoped variable for the
-exception thrown from a nested action. The type of the
-scoped variable is the type of the exception thrown.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Simple conditional tag that establishes a context for
- mutually exclusive conditional operations, marked by
- <when> and <otherwise>
- </description>
- <name>choose</name>
- <tag-class>org.apache.taglibs.standard.tag.common.core.ChooseTag</tag-class>
- <body-content>JSP</body-content>
- </tag>
-
- <tag>
- <description>
- Simple conditional tag, which evalutes its body if the
- supplied condition is true and optionally exposes a Boolean
- scripting variable representing the evaluation of this condition
- </description>
- <name>if</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.core.IfTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-The test condition that determines whether or
-not the body content should be processed.
- </description>
- <name>test</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- <type>boolean</type>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable for the
-resulting value of the test condition. The type
-of the scoped variable is Boolean.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope for var.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Retrieves an absolute or relative URL and exposes its contents
- to either the page, a String in 'var', or a Reader in 'varReader'.
- </description>
- <name>import</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.core.ImportTag</tag-class>
- <tei-class>org.apache.taglibs.standard.tei.ImportTEI</tei-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-The URL of the resource to import.
- </description>
- <name>url</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable for the
-resource's content. The type of the scoped
-variable is String.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope for var.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable for the
-resource's content. The type of the scoped
-variable is Reader.
- </description>
- <name>varReader</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the context when accessing a relative
-URL resource that belongs to a foreign
-context.
- </description>
- <name>context</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Character encoding of the content at the input
-resource.
- </description>
- <name>charEncoding</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- The basic iteration tag, accepting many different
- collection types and supporting subsetting and other
- functionality
- </description>
- <name>forEach</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.core.ForEachTag</tag-class>
- <tei-class>org.apache.taglibs.standard.tei.ForEachTEI</tei-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-Collection of items to iterate over.
- </description>
- <name>items</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- <type>java.lang.Object</type>
- <deferred-value>
- <type>java.lang.Object</type>
- </deferred-value>
- </attribute>
- <attribute>
- <description>
-If items specified:
-Iteration begins at the item located at the
-specified index. First item of the collection has
-index 0.
-If items not specified:
-Iteration begins with index set at the value
-specified.
- </description>
- <name>begin</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- <type>int</type>
- </attribute>
- <attribute>
- <description>
-If items specified:
-Iteration ends at the item located at the
-specified index (inclusive).
-If items not specified:
-Iteration ends when index reaches the value
-specified.
- </description>
- <name>end</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- <type>int</type>
- </attribute>
- <attribute>
- <description>
-Iteration will only process every step items of
-the collection, starting with the first one.
- </description>
- <name>step</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- <type>int</type>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable for the
-current item of the iteration. This scoped
-variable has nested visibility. Its type depends
-on the object of the underlying collection.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable for the
-status of the iteration. Object exported is of type
-javax.servlet.jsp.jstl.core.LoopTagStatus. This scoped variable has nested
-visibility.
- </description>
- <name>varStatus</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Iterates over tokens, separated by the supplied delimeters
- </description>
- <name>forTokens</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.core.ForTokensTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-String of tokens to iterate over.
- </description>
- <name>items</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- <type>java.lang.String</type>
- <deferred-value>
- <type>java.lang.String</type>
- </deferred-value>
- </attribute>
- <attribute>
- <description>
-The set of delimiters (the characters that
-separate the tokens in the string).
- </description>
- <name>delims</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- <type>java.lang.String</type>
- </attribute>
- <attribute>
- <description>
-Iteration begins at the token located at the
-specified index. First token has index 0.
- </description>
- <name>begin</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- <type>int</type>
- </attribute>
- <attribute>
- <description>
-Iteration ends at the token located at the
-specified index (inclusive).
- </description>
- <name>end</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- <type>int</type>
- </attribute>
- <attribute>
- <description>
-Iteration will only process every step tokens
-of the string, starting with the first one.
- </description>
- <name>step</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- <type>int</type>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable for the
-current item of the iteration. This scoped
-variable has nested visibility.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable for the
-status of the iteration. Object exported is of
-type
-javax.servlet.jsp.jstl.core.LoopTag
-Status. This scoped variable has nested
-visibility.
- </description>
- <name>varStatus</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Like <%= ... >, but for expressions.
- </description>
- <name>out</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.core.OutTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-Expression to be evaluated.
- </description>
- <name>value</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Default value if the resulting value is null.
- </description>
- <name>default</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Determines whether characters <,>,&,'," in the
-resulting string should be converted to their
-corresponding character entity codes. Default value is
-true.
- </description>
- <name>escapeXml</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- </tag>
-
-
- <tag>
- <description>
- Subtag of <choose> that follows <when> tags
- and runs only if all of the prior conditions evaluated to
- 'false'
- </description>
- <name>otherwise</name>
- <tag-class>org.apache.taglibs.standard.tag.common.core.OtherwiseTag</tag-class>
- <body-content>JSP</body-content>
- </tag>
-
- <tag>
- <description>
- Adds a parameter to a containing 'import' tag's URL.
- </description>
- <name>param</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.core.ParamTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-Name of the query string parameter.
- </description>
- <name>name</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Value of the parameter.
- </description>
- <name>value</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Redirects to a new URL.
- </description>
- <name>redirect</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.core.RedirectTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-The URL of the resource to redirect to.
- </description>
- <name>url</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the context when redirecting to a relative URL
-resource that belongs to a foreign context.
- </description>
- <name>context</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Removes a scoped variable (from a particular scope, if specified).
- </description>
- <name>remove</name>
- <tag-class>org.apache.taglibs.standard.tag.common.core.RemoveTag</tag-class>
- <body-content>empty</body-content>
- <attribute>
- <description>
-Name of the scoped variable to be removed.
- </description>
- <name>var</name>
- <required>true</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope for var.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Sets the result of an expression evaluation in a 'scope'
- </description>
- <name>set</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.core.SetTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-Name of the exported scoped variable to hold the value
-specified in the action. The type of the scoped variable is
-whatever type the value expression evaluates to.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Expression to be evaluated.
- </description>
- <name>value</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- <deferred-value>
- <type>java.lang.Object</type>
- </deferred-value>
- </attribute>
- <attribute>
- <description>
-Target object whose property will be set. Must evaluate to
-a JavaBeans object with setter property property, or to a
-java.util.Map object.
- </description>
- <name>target</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the property to be set in the target object.
- </description>
- <name>property</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope for var.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Creates a URL with optional query parameters.
- </description>
- <name>url</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.core.UrlTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-Name of the exported scoped variable for the
-processed url. The type of the scoped variable is
-String.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope for var.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-URL to be processed.
- </description>
- <name>value</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the context when specifying a relative URL
-resource that belongs to a foreign context.
- </description>
- <name>context</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Subtag of <choose> that includes its body if its
- condition evalutes to 'true'
- </description>
- <name>when</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.core.WhenTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-The test condition that determines whether or not the
-body content should be processed.
- </description>
- <name>test</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- <type>boolean</type>
- </attribute>
- </tag>
-
-</taglib>
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/web-app/WEB-INF/tld/fmt.tld
----------------------------------------------------------------------
diff --git a/wicket-user-guide/web-app/WEB-INF/tld/fmt.tld b/wicket-user-guide/web-app/WEB-INF/tld/fmt.tld
deleted file mode 100644
index 2ae4776..0000000
--- a/wicket-user-guide/web-app/WEB-INF/tld/fmt.tld
+++ /dev/null
@@ -1,671 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" ?>
-
-<taglib xmlns="http://java.sun.com/xml/ns/javaee"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-jsptaglibrary_2_1.xsd"
- version="2.1">
-
- <description>JSTL 1.2 i18n-capable formatting library</description>
- <display-name>JSTL fmt</display-name>
- <tlib-version>1.2</tlib-version>
- <short-name>fmt</short-name>
- <uri>http://java.sun.com/jsp/jstl/fmt</uri>
-
- <validator>
- <description>
- Provides core validation features for JSTL tags.
- </description>
- <validator-class>
- org.apache.taglibs.standard.tlv.JstlFmtTLV
- </validator-class>
- </validator>
-
- <tag>
- <description>
- Sets the request character encoding
- </description>
- <name>requestEncoding</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.RequestEncodingTag</tag-class>
- <body-content>empty</body-content>
- <attribute>
- <description>
-Name of character encoding to be applied when
-decoding request parameters.
- </description>
- <name>value</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Stores the given locale in the locale configuration variable
- </description>
- <name>setLocale</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetLocaleTag</tag-class>
- <body-content>empty</body-content>
- <attribute>
- <description>
-A String value is interpreted as the
-printable representation of a locale, which
-must contain a two-letter (lower-case)
-language code (as defined by ISO-639),
-and may contain a two-letter (upper-case)
-country code (as defined by ISO-3166).
-Language and country codes must be
-separated by hyphen (-) or underscore
-(_).
- </description>
- <name>value</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Vendor- or browser-specific variant.
-See the java.util.Locale javadocs for
-more information on variants.
- </description>
- <name>variant</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope of the locale configuration variable.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Specifies the time zone for any time formatting or parsing actions
- nested in its body
- </description>
- <name>timeZone</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.TimeZoneTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-The time zone. A String value is interpreted as
-a time zone ID. This may be one of the time zone
-IDs supported by the Java platform (such as
-"America/Los_Angeles") or a custom time zone
-ID (such as "GMT-8"). See
-java.util.TimeZone for more information on
-supported time zone formats.
- </description>
- <name>value</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Stores the given time zone in the time zone configuration variable
- </description>
- <name>setTimeZone</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetTimeZoneTag</tag-class>
- <body-content>empty</body-content>
- <attribute>
- <description>
-The time zone. A String value is interpreted as
-a time zone ID. This may be one of the time zone
-IDs supported by the Java platform (such as
-"America/Los_Angeles") or a custom time zone
-ID (such as "GMT-8"). See java.util.TimeZone for
-more information on supported time zone
-formats.
- </description>
- <name>value</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable which
-stores the time zone of type
-java.util.TimeZone.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope of var or the time zone configuration
-variable.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Loads a resource bundle to be used by its tag body
- </description>
- <name>bundle</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.BundleTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-Resource bundle base name. This is the bundle's
-fully-qualified resource name, which has the same
-form as a fully-qualified class name, that is, it uses
-"." as the package component separator and does not
-have any file type (such as ".class" or ".properties")
-suffix.
- </description>
- <name>basename</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Prefix to be prepended to the value of the message
-key of any nested <fmt:message> action.
- </description>
- <name>prefix</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Loads a resource bundle and stores it in the named scoped variable or
- the bundle configuration variable
- </description>
- <name>setBundle</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.SetBundleTag</tag-class>
- <body-content>empty</body-content>
- <attribute>
- <description>
-Resource bundle base name. This is the bundle's
-fully-qualified resource name, which has the same
-form as a fully-qualified class name, that is, it uses
-"." as the package component separator and does not
-have any file type (such as ".class" or ".properties")
-suffix.
- </description>
- <name>basename</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable which stores
-the i18n localization context of type
-javax.servlet.jsp.jstl.fmt.LocalizationC
-ontext.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope of var or the localization context
-configuration variable.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Maps key to localized message and performs parametric replacement
- </description>
- <name>message</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.MessageTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-Message key to be looked up.
- </description>
- <name>key</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Localization context in whose resource
-bundle the message key is looked up.
- </description>
- <name>bundle</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable
-which stores the localized message.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope of var.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Supplies an argument for parametric replacement to a containing
- <message> tag
- </description>
- <name>param</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParamTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-Argument used for parametric replacement.
- </description>
- <name>value</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Formats a numeric value as a number, currency, or percentage
- </description>
- <name>formatNumber</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatNumberTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-Numeric value to be formatted.
- </description>
- <name>value</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Specifies whether the value is to be
-formatted as number, currency, or
-percentage.
- </description>
- <name>type</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Custom formatting pattern.
- </description>
- <name>pattern</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-ISO 4217 currency code. Applied only
-when formatting currencies (i.e. if type is
-equal to "currency"); ignored otherwise.
- </description>
- <name>currencyCode</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Currency symbol. Applied only when
-formatting currencies (i.e. if type is equal
-to "currency"); ignored otherwise.
- </description>
- <name>currencySymbol</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Specifies whether the formatted output
-will contain any grouping separators.
- </description>
- <name>groupingUsed</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Maximum number of digits in the integer
-portion of the formatted output.
- </description>
- <name>maxIntegerDigits</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Minimum number of digits in the integer
-portion of the formatted output.
- </description>
- <name>minIntegerDigits</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Maximum number of digits in the
-fractional portion of the formatted output.
- </description>
- <name>maxFractionDigits</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Minimum number of digits in the
-fractional portion of the formatted output.
- </description>
- <name>minFractionDigits</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable
-which stores the formatted result as a
-String.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope of var.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Parses the string representation of a number, currency, or percentage
- </description>
- <name>parseNumber</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseNumberTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-String to be parsed.
- </description>
- <name>value</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Specifies whether the string in the value
-attribute should be parsed as a number,
-currency, or percentage.
- </description>
- <name>type</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Custom formatting pattern that determines
-how the string in the value attribute is to be
-parsed.
- </description>
- <name>pattern</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Locale whose default formatting pattern (for
-numbers, currencies, or percentages,
-respectively) is to be used during the parse
-operation, or to which the pattern specified
-via the pattern attribute (if present) is
-applied.
- </description>
- <name>parseLocale</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Specifies whether just the integer portion of
-the given value should be parsed.
- </description>
- <name>integerOnly</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable which
-stores the parsed result (of type
-java.lang.Number).
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope of var.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Formats a date and/or time using the supplied styles and pattern
- </description>
- <name>formatDate</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.FormatDateTag</tag-class>
- <body-content>empty</body-content>
- <attribute>
- <description>
-Date and/or time to be formatted.
- </description>
- <name>value</name>
- <required>true</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Specifies whether the time, the date, or both
-the time and date components of the given
-date are to be formatted.
- </description>
- <name>type</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Predefined formatting style for dates. Follows
-the semantics defined in class
-java.text.DateFormat. Applied only
-when formatting a date or both a date and
-time (i.e. if type is missing or is equal to
-"date" or "both"); ignored otherwise.
- </description>
- <name>dateStyle</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Predefined formatting style for times. Follows
-the semantics defined in class
-java.text.DateFormat. Applied only
-when formatting a time or both a date and
-time (i.e. if type is equal to "time" or "both");
-ignored otherwise.
- </description>
- <name>timeStyle</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Custom formatting style for dates and times.
- </description>
- <name>pattern</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Time zone in which to represent the formatted
-time.
- </description>
- <name>timeZone</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable which
-stores the formatted result as a String.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope of var.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
- <tag>
- <description>
- Parses the string representation of a date and/or time
- </description>
- <name>parseDate</name>
- <tag-class>org.apache.taglibs.standard.tag.rt.fmt.ParseDateTag</tag-class>
- <body-content>JSP</body-content>
- <attribute>
- <description>
-Date string to be parsed.
- </description>
- <name>value</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Specifies whether the date string in the
-value attribute is supposed to contain a
-time, a date, or both.
- </description>
- <name>type</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Predefined formatting style for days
-which determines how the date
-component of the date string is to be
-parsed. Applied only when formatting a
-date or both a date and time (i.e. if type
-is missing or is equal to "date" or "both");
-ignored otherwise.
- </description>
- <name>dateStyle</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Predefined formatting styles for times
-which determines how the time
-component in the date string is to be
-parsed. Applied only when formatting a
-time or both a date and time (i.e. if type
-is equal to "time" or "both"); ignored
-otherwise.
- </description>
- <name>timeStyle</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Custom formatting pattern which
-determines how the date string is to be
-parsed.
- </description>
- <name>pattern</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Time zone in which to interpret any time
-information in the date string.
- </description>
- <name>timeZone</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Locale whose predefined formatting styles
-for dates and times are to be used during
-the parse operation, or to which the
-pattern specified via the pattern
-attribute (if present) is applied.
- </description>
- <name>parseLocale</name>
- <required>false</required>
- <rtexprvalue>true</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Name of the exported scoped variable in
-which the parsing result (of type
-java.util.Date) is stored.
- </description>
- <name>var</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- <attribute>
- <description>
-Scope of var.
- </description>
- <name>scope</name>
- <required>false</required>
- <rtexprvalue>false</rtexprvalue>
- </attribute>
- </tag>
-
-</taglib>