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:58 UTC
[16/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/docs/guide/modelsforms/modelsforms_3.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_3.gdoc b/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_3.gdoc
deleted file mode 100644
index 824e417..0000000
--- a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_3.gdoc
+++ /dev/null
@@ -1,144 +0,0 @@
-
-
-One of the main goals of Wicket is to use JavaBeans and POJO as data model, overcoming the impedance mismatch between web technologies and OO paradigm. In order to make this task as easy as possible, Wicket offers two special model classes: @org.apache.wicket.model.PropertyModel@ and @org.apache.wicket.model.CompoundPropertyModel@. We will see how to use them in the next two examples, using the following JavaBean as the data object:
-
-{code}
-public class Person implements Serializable {
-
- private String name;
- private String surname;
- private String address;
- private String email;
- private String passportCode;
-
- private Person spouse;
- private List<Person> children;
-
- public Person(String name, String surname) {
- this.name = name;
- this.surname = surname;
- }
-
- public String getFullName(){
- return name + " " + surname;
- }
-
- /*
- * Getters and setters for private fields
- */
-}
-{code}
-
-h3. PropertyModel
-
-Let's say we want to display the name field of a Person instance with a label. We could, of course, use the Model class like we did in the previous example, obtaining something like this:
-
-{code}
-Person person = new Person();
-//load person's data...
-
-Label label = new Label("name", new Model(person.getName()));
-{code}
-
-However this solution has a huge drawback: the text displayed by the label will be static and if we change the value of the field, the label won't update its content. Instead, to always display the current value of a class field, we should use the @org.apache.wicket.model.PropertyModel@ model class:
-
-{code}
-Person person = new Person();
-//load person's data...
-
-Label label = new Label("name", new PropertyModel(person, "name"));
-{code}
-
-PropertyModel has just one constructor with two parameters: the model object (person in our example) and the name of the property we want to read/write ("name" in our example). This last parameter is called property expression. Internally, methods getObject/setObject use property expression to get/set property's value. To resolve class properties PropertyModel uses class @org.apache.wicket.util.lang.Property@ Resolver which can access any kind of property, private fields included.
-
-Just like the Java language, property expressions support dotted notation to select sub properties. So if we want to display the name of the Person's spouse we can write:
-
-{code}
-Label label = new Label("spouseName", new PropertyModel(person, "spouse.name"));
-{code}
-
-{note}
-PropertyModel is null-safe, which means we don't have to worry if property expression includes a null value in its path. If such a value is encountered, an empty string will be returned.
-{note}
-
-If property is an array or a List, we can specify an index after its name. For example, to display the name of the first child of a Person we can write the following property expression:
-
-{code}
-Label label = new Label("firstChildName", new PropertyModel(person, "children.0.name"));
-{code}
-
-Indexes and map keys can be also specified using squared brackets:
-
-{code}
-children[0].name ...
-mapField[key].subfield ...
-{code}
-
-h3. LambdaModel
-
-@PropertyModel@ uses textual expressions to resolve object properties. That's nice but it comes with some drawbacks. For example the expression can not be checked at compile time and is not refactory-friendly. To overcome these problems with Wicket 8 a new kind of lambda-based model has been introduced: @org.apache.wicket.model.LambdaModel@. This model uses lambda expressions to get/set model object. Here is the signature of its constructor:
-
-{code}
-public LambdaModel(SerializableSupplier<T> getter, SerializableConsumer<T> setter)
-{code}
-
-In the following code we use method references to operate on a specific object property:
-
-{code}
-Person person = new Person();
-IModel<String> personNameModel = new LambdaModel<>(person::getName, person::setName);
-{code}
-
-As we have seen for @Model@ also @LambdaModel@ comes with factory method @LambdaModel.of@:
-
-{code}
-Person person = new Person();
-IModel<String> personNameModel = LambdaModel.of(person::getName, person::setName);
-{code}
-
-
-h3. CompoundPropertyModel and model inheritance
-
-Class @org.apache.wicket.model.CompoundPropertyModel@ is a particular kind of model which is usually used in conjunction with another Wicket feature called model inheritance. With this feature, when a component needs to use a model but none has been assigned to it, it will search through the whole container hierarchy for a parent with an inheritable model. Inheritable models are those which implement interface @org.apache.wicket.model.IComponentInheritedModel@ and @CompoundPropertyModel@ is one of them. Once a @CompoundPropertyModel@ has been inherited by a component, it will behave just like a PropertyModel using the id of the component as property expression. As a consequence, to make the most of CompoundPropertyModel we must assign it to one of the containers of a given component, rather than directly to the component itself.
-
-For example if we use CompoundPropertyModel with the previous example (display spouse's name), the code would become like this:
-
-{code}
-//set CompoundPropertyModel as model for the container of the label
-setDefaultModel(new CompoundPropertyModel(person));
-
-Label label = new Label("spouse.name");
-
-add(label);
-{code}
-
-Note that now the id of the label is equal to the property expression previously used with PropertyModel. Now as a further example let's say we want to extend the code above to display all of the main informations of a person (name, surname, address and email). All we have to do is to add one label for every additional information using the relative property expression as component id:
-
-{code}
-//Create a person named 'John Smith'
-Person person = new Person("John", "Smith");
-setDefaultModel(new CompoundPropertyModel(person));
-
-add(new Label("name"));
-add(new Label("surname"));
-add(new Label("address"));
-add(new Label("email"));
-add(new Label("spouse.name"));
-{code}
-
-CompoundPropertyModel can save us a lot of boring coding if we choose the id of components according to properties name. However it's also possible to use this type of model even if the id of a component does not correspond to a valid property expression. The method bind(String property) allows to create a property model from a given CompoundPropertyModel using the provided parameter as property expression. For example if we want to display the spouse's name in a label having "xyz" as id, we can write the following code:
-
-{code}
-//Create a person named 'John Smith'
-Person person = new Person("John", "Smith");
-CompoundPropertyModel compoundModel;
-setDefaultModel(compoundModel = new CompoundPropertyModel(person));
-
-add(new Label("xyz", compoundModel.bind("spouse.name")));
-{code}
-
-CompoundPropertyModel are particularly useful when used in combination with Wicket forms, as we will see in the next paragraph.
-
-{note}
-Model is referred to as static model because the result of its method getObject is fixed and it is not dynamically evaluated each time the method is called. In contrast, models like PropertyModel and CompoundProperty Model are called dynamic models.
-{note}
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_4.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_4.gdoc b/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_4.gdoc
deleted file mode 100644
index 25c7840..0000000
--- a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_4.gdoc
+++ /dev/null
@@ -1,185 +0,0 @@
-
-
-Web applications use HTML forms to collect user input and send it to the server. Wicket provides @org.apache.wicket.markup.html.form.Form@ class to handle web forms. This component must be bound to <form> tag. The following snippet shows how to create a very basic Wicket form in a page:
-
-Html:
-
-{code:html}
-<form wicket:id="form">
- <input type="submit" value="submit"/>
-</form>
-{code}
-
-
-Java code:
-
-{code}
-Form form = new Form("form"){
- @Override
- protected void onSubmit() {
- System.out.println("Form submitted.");
- }
-};
-add(form);
-{code}
-
-Method onSubmit is called whenever a form has been submitted and it can be overridden to perform custom actions. Please note that a Wicket form can be submitted using a standard HTML submit button which is not mapped to any component (i.e. it does not have a wicket:id attribute).
-In the next chapter we will continue to explore Wicket forms and we will see how to submit forms using special components which implement interface @org.apache.wicket.markup.html.form.IFormSubmitter@.
-
-h3. Form and models
-
-A form should contain some input fields (like text fields, check boxes, radio buttons, drop-down lists, text areas, etc.) to interact with users. Wicket provides an abstraction for all these kinds of elements with component org.apache.wicket.markup.html.form.FormComponent:
-
-!uml-form-component.png!
-
-The purpose of FormComponent is to store the corresponding user input into its model when the form is submitted. The form is responsible for mapping input values to the corresponding components, avoiding us the burden of manually synchronizing models with input fields and vice versa.
-
-h3. Login form
-
-As first example of interaction between the form and its models, we will build a classic login form which asks for username and password (project LoginForm).
-
-{warning}
-The topic of security will be discussed later in chapter 22. The following form is for example purposes only and is not suited for a real application.
-If you need to use a login form you should consider to use component @org.apache.wicket.authroles.authentication.panel.SignInPanel@ shipped with Wicket.
-{warning}
-
-This form needs two text fields, one of which must be a password field. We should also use a label to display the result of login process1. For the sake of simplicity, the login logic is all inside onSubmit and is quite trivial.
-
-The following is a possible implementation of our form:
-
-{code}
-public class LoginForm extends Form {
-
- private TextField usernameField;
- private PasswordTextField passwordField;
- private Label loginStatus;
-
- public LoginForm(String id) {
- super(id);
-
- usernameField = new TextField("username", Model.of(""));
- passwordField = new PasswordTextField("password", Model.of(""));
- loginStatus = new Label("loginStatus", Model.of(""));
-
- add(usernameField);
- add(passwordField);
- add(loginStatus);
- }
-
- public final void onSubmit() {
- String username = (String)usernameField.getDefaultModelObject();
- String password = (String)passwordField.getDefaultModelObject();
-
- if(username.equals("test") && password.equals("test"))
- loginStatus.setDefaultModelObject("Congratulations!");
- else
- loginStatus.setDefaultModelObject("Wrong username or password!");
- }
-}
-{code}
-
-Inside form's constructor we build the three components used in the form and we assign them a model containing an empty string:
-
-{code}
-usernameField = new TextField("username", Model.of(""));
-passwordField = new PasswordTextField("password", Model.of(""));
-loginStatus = new Label("loginStatus", Model.of(""));
-{code}
-
-If we don't provide a model to a form component, we will get the following exception on form submission:
-
-{code}
-java.lang.IllegalStateException: Attempt to set model object on null model of component:
-{code}
-
-Component TextField corresponds to the standard text field, without any particular behavior or restriction on the allowed values. We must bind this component to the <input> tag with the attribute type set to "text". PasswordTextField is a subtype of TextFiled and it must be used with an <input> tag with the attribute type set to"password". For security reasons component PasswordTextField cleans its value at each request, so it wil be always empty after the form has been rendered. By default PasswordTextField fields are required, meaning that if we left them empty, the form won't be submitted (i.e. onSubmit won't be called). Class FormComponent provides method setRequired(boolean required) to change this behavior. Inside onSubmit, to get/set model objects we have used shortcut methods setDefaultModelObject and getDefaultModelObject. Both methods are defined in class Component (see class diagram from Illustration 9.1).
-
-The following are the possible markup and code for the login page:
-
-Html:
-
-{code:html}
-<html>
- <head>
- <title>Login page</title>
- </head>
- <body>
- <form id="loginForm" method="get" wicket:id="loginForm">
- <fieldset>
- <legend style="color: #F90">Login</legend>
- <p wicket:id="loginStatus"></p>
- <span>Username: </span><input wicket:id="username" type="text" id="username" /><br/>
- <span>Password: </span><input wicket:id="password" type="password" id="password" />
- <p>
- <input type="submit" name="Login" value="Login"/>
- </p>
- </fieldset>
- </form>
- </body>
-</html>
-{code}
-
-Java code:
-
-{code}
-public class HomePage extends WebPage {
-
- public HomePage(final PageParameters parameters) {
-
- super(parameters);
- add(new LoginForm("loginForm"));
-
- }
-}
-{code}
-
-The example shows how Wicket form components can be used to store user input inside their model. However we can dramatically improve the form code using CompoundPropertyModel and its ability to access the properties of its model object. The revisited code is the following (the LoginFormRevisited project):
-
-{code}
-public class LoginForm extends Form{
-
- private String username;
- private String password;
- private String loginStatus;
-
- public LoginForm(String id) {
- super(id);
- setDefaultModel(new CompoundPropertyModel(this));
-
- add(new TextField("username"));
- add(new PasswordTextField("password"));
- add(new Label("loginStatus"));
- }
-
- public final void onSubmit() {
- if(username.equals("test") && password.equals("test"))
- loginStatus = "Congratulations!";
- else
- loginStatus = "Wrong username or password !";
- }
- }
-{code}
-
-In this version the form itself is used as model object for its CompoundPropertyModel. This allows children components to have direct access to form fields and use them as backing objects, without explicitly creating a model for themselves.
-
-{note}
-Keep in mind that when CompoundPropertyModel is inherited, it does not consider the ids of traversed containers for the final property expression, but it will always use the id of the visited child. To understand this potential pitfall, let's consider the following initialization code of a page:
-
-{code}
-//Create a person named 'John Smith'
-Person person = new Person("John", "Smith");
-//Create a person named 'Jill Smith'
-Person spouse = new Person("Jill", "Smith");
-//Set Jill as John's spouse
-person.setSpouse(spouse);
-
-setDefaultModel(new CompoundPropertyModel(person));
-WebMarkupContainer spouseContainer = new WebMarkupContainer("spouse");
-Label name;
-spouseContainer.add(name = new Label("name"));
-
-add(spouseContainer);
-{code}
-
-The value displayed by label "name" will be "John" and not the spouse's name "Jill" as you may expect. In this example the label doesn't own a model, so it must search up its container hierarchy for an inheritable model. However, its container (WebMarkup Container with id 'spouse') doesn't own a model, hence the request for a model is forwarded to the parent container, which in this case is the page. In the end the label inherits CompoundPropertyModel from page but only its own id is used for the property expression. The containers in between are never taken into account for the final property expression.
-{note}
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_5.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_5.gdoc b/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_5.gdoc
deleted file mode 100644
index 9d8695f..0000000
--- a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_5.gdoc
+++ /dev/null
@@ -1,54 +0,0 @@
-
-
-Class @org.apache.wicket.markup.html.form.DropDownChoice@ is the form component needed to display a list of possible options as a drop-down list where users can select one of the proposed options. This component must be used with <select> tag:
-
-Html:
-
-{code:html}
-<form wicket:id="form">
- Select a fruit: <select wicket:id="fruits"></select>
-<div><input type="submit" value="submit"/></div>
-</form>
-{code}
-
-Java code:
-
-{code}
-List<String> fruits = Arrays.asList("apple", "strawberry", "watermelon");
-form.add(new DropDownChoice<String>("fruits", new Model(), fruits));
-{code}
-
-Screenshot of generated page:
-
-!dropdown-choice.png!
-
-In addition to the component id, in order to build a DropDownChoice we need to provide to its constructor two further parameters:
-
-* a model containing the current selected item. This parameter is not required if we are going to inherit a CompoundPropertyModel for this component.
-* a list of options to display which can be supplied as a model or as a regular java.util.List.
-
-In the example above the possible options are provided as a list of String objects. Now let's take a look at the markup generated for them:
-
-{code:html}
-<select name="fruits" wicket:id="fruits">
- <option value="" selected="selected">Choose One</option>
- <option value="0">apple</option>
- <option value="1">strawberry</option>
- <option value="2">watermelon</option>
-</select>
-{code}
-
-The first option is a placeholder item corresponding to a null model value. By default DropDownChoice cannot have a null value so users are forced to select a not-null option. If we want to change this behavior we can set the nullValid flag to true via the setNullValid method. Please note that the placeholder text (\u201cChose one\u201d) can be localized, as we will see in chapter 15. The other options are identified by the attribute value. By default the value of this attribute is the index of the single option inside the provided list of choices, while the text displayed to the user is obtained by calling toString()on the choice object. This default behavior works fine as long as our options are simple objects like strings, but when we move to more complex objects we may need to implement a more sophisticated algorithm to generate the value to use as the option id and the one to display to user. Wicket has solved this problem with @org.apache.wicket.markup.html.form.IChoiceRender@ inte
rface. This interface defines method getDisplayValue(T object) that is called to generate the value to display for the given choice object, and method getIdValue(T object, int index) that is called to generate the option id. The built-in implementation of this interface is class @org.apache.wicket.markup.html.form.ChoiceRenderer@ which renders the two values using property expressions.
-
-In the following code we want to show a list of Person objects using their full name as value to display and using their passport code as option id:
-
-Java code:
-
-{code}
-List<Person> persons;
-//Initialize the list of persons here...
-ChoiceRenderer personRenderer = new ChoiceRenderer("fullName", "passportCode");
-form.add(new DropDownChoice<String>("persons", new Model<Person>(), persons, personRenderer));
-{code}
-
-The choice renderer can be assigned to the DropDownChoice using one of its constructor that accepts this type of parameter (like we did in the example above) or after its creation invoking setChoiceRenderer method.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_6.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_6.gdoc b/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_6.gdoc
deleted file mode 100644
index a194524..0000000
--- a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_6.gdoc
+++ /dev/null
@@ -1,101 +0,0 @@
-
-
-Models that implement the interface @org.apache.wicket.model.IChainingModel@ can be used to build a chain of models. These kinds of models are able to recognize whether their model object is itself an implementation of IModel and if so, they will call getObject on the wrapped model and the returned value will be the actual model object. In this way we can combine the action of an arbitrary number of models, making exactly a chain of models. Chaining models allows to combine different data persistence strategies, similarly to what we do with chains of "I/O streams.":http://java.sun.com/developer/technicalArticles/Streams/ProgIOStreams To see model chaining in action we will build a page that implements the List/Detail View pattern, where we have a drop-down list of Person objects and a form to display and edit the data of the current selected Person.
-
-The example page will look like this:
-
-!model-chaining.png!
-
-What we want to do in this example is to chain the model of the DropDownChoice (which contains the selected Person) with the model of the Form. In this way the Form will work with the selected Person as backing object. The DropDownChoice component can be configured to automatically update its model each time we change the selected item on the client side. All we have to do is to override method wantOnSelectionChangedNotifications to make it return true. In practice, when this method returns true, DropDownChoice will submit its value every time JavaScript event onChange occurs, and its model will be consequently updated. To leverage this functionality, DropDownChoice doesn't need to be inside a form.
-
-The following is the resulting markup of the example page:
-
-{code:html}
-...
-<body>
- List of persons <select wicket:id="persons"></select> <br/>
- <br/>
- <form wicket:id="form">
- <div style="display: table;">
- <div style="display: table-row;">
- <div style="display: table-cell;">Name: </div>
- <div style="display: table-cell;">
- <input type="text" wicket:id="name"/>
- </div>
- </div>
- <div style="display: table-row;">
- <div style="display: table-cell;">Surname: </div>
- <div style="display: table-cell;">
- <input type="text" wicket:id="surname"/>
- </div>
- </div>
- <div style="display: table-row;">
- <div style="display: table-cell;">Address: </div>
- <div style="display: table-cell;">
- <input type="text" wicket:id="address"/>
- </div>
- </div>
- <div style="display: table-row;">
- <div style="display: table-cell;">Email: </div>
- <div style="display: table-cell;">
- <input type="text" wicket:id="email"/>
- </div>
- </div>
- </div>
- <input type="submit" value="Save"/>
- </form>
- </body>
-{code}
-
-The initialization code for DropDownChoice is the following:
-
-{code}
-Model<Person> listModel = new Model<Person>();
-ChoiceRenderer<Person> personRender = new ChoiceRenderer<Person>("fullName");
-personsList = new DropDownChoice<Person>("persons", listModel, loadPersons(), personRender){
-
- @Override
- protected boolean wantOnSelectionChangedNotifications() {
- return true;
- }
-
-};
-{code}
-
-As choice render we have used the basic implementation provided with the org.apache.wicket .markup.html.form.ChoiceRenderer class that we have seen in the previous paragraph. loadPersons() is just an utility method which generates a list of Person instances. The model for DropDownChoice is a simple instance of the Model class.
-
-Here is the whole code of the page (except for the loadPersons() method):
-
-{code}
-public class PersonListDetails extends WebPage {
- private Form form;
- private DropDownChoice<Person> personsList;
-
- public PersonListDetails(){
- Model<Person> listModel = new Model<Person>();
- ChoiceRenderer<Person> personRender = new ChoiceRenderer<Person>("fullName");
-
- personsList = new DropDownChoice<Person>("persons", listModel, loadPersons(),
- personRender){
- @Override
- protected boolean wantOnSelectionChangedNotifications() {
- return true;
- }
- };
-
- add(personsList);
-
- form = new Form("form", new CompoundPropertyModel<Person>(listModel));
- form.add(new TextField("name"));
- form.add(new TextField("surname"));
- form.add(new TextField("address"));
- form.add(new TextField("email"));
-
- add(form);
- }
- //loadPersons()
- //...
- }
-{code}
-
-The two models work together as a pipeline where the output of method getObject of Model is the model object of CompoundPropertyModel. As we have seen, model chaining allows us to combine the actions of two or more models without creating new custom implementations.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_7.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_7.gdoc b/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_7.gdoc
deleted file mode 100644
index 2a9a097..0000000
--- a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_7.gdoc
+++ /dev/null
@@ -1,82 +0,0 @@
-
-
-In chapter 6 we have seen how Wicket uses serialization to store page instances. When an object is serialized, all its referenced objects are recursively serialized. For a page this means that all its children components, their related models as well as the model objects inside them will be serialized.
-For model objects this could be a serious issue for (at least) two main reasons:
-
-# The model object could be a very large instance, hence serialization would become very expensive in terms of time and memory.
-# We simply may not be able to use a serializable object as model object. In paragraphs 1.4 and 9.2 we stated that Wicket allows us to use a POJO as backing object, but "POJOs":http://en.wikipedia.org/wiki/Plain_Old_Java_Object#Definition are ordinary objects with no prespecified interface, annotation or superclass, hence they are not required to implement the standard Serializable interface.
-
-To cope with these problems IModel extends another interface called IDetachable.
-
-!detachable-models.png!
-
-This interface provides a method called detach() which is invoked by Wicket at the end of web request processing when data model is no more needed but before serialization occurs. Overriding this method we can clean any reference to data object keeping just the information needed to retrieve it later (for example the id of the table row where our data are stored). In this way we can avoid the serialization of the object wrapped into the model overcoming both the problem with non-serializable objects and the one with large data objects.
-
-Since IModel inherits from IDetachable, every model of Wicket is \u201cdetachable\u201d, although not all of them implement a detaching policy (like the Model class).
-Usually detaching operations are strictly dependent on the persistence technology adopted for model objects (like a relational db, a NoSQL db, a queue, etc), so it's not unusual to write a custom detachable model suited for the persistence technology chosen for a given project. To ease this task Wicket provides abstract model LoadableDetachableModel. This class internally holds a transient reference to a model object which is initialized the first time getObject()is called to precess a request. The concrete data loading is delegated to abstract method T load(). The reference to a model object is automatically set to null at the end of the request by the detach() method.
-
-The following class diagram summarizes the methods defined inside LoadableDetachableModel.
-
-!loadable-detachable-model.png!
-
-onDetach and onAttach can be overridden in order to obtain further control over the detaching procedure.
-
-Now as example of a possible use of LoadableDetachableModel, we will build a model designed to work with entities managed via "JPA.":http://en.wikipedia.org/wiki/Java_Persistence_API To understand the following code a basic knowledge of JPA is required even if we won't go into the detail of this standard.
-
-{warning}
-The following model is provided for example purposes only and is not intended to be used in production environment. Important aspects such as transaction management are not taken into account and you should rework the code before considering to use it.
-{warning}
-
-{code}
-public class JpaLoadableModel<T> extends LoadableDetachableModel<T> {
-
- private EntityManagerFactory entityManagerFactory;
- private Class<T> entityClass;
- private Serializable identifier;
- private List<Object> constructorParams;
-
- public JpaLoadableModel(EntityManagerFactory entityManagerFactory, T entity) {
-
- super();
-
- PersistenceUnitUtil util = entityManagerFactory.getPersistenceUnitUtil();
-
- this.entityManagerFactory = entityManagerFactory;
- this.entityClass = (Class<T>) entity.getClass();
- this.identifier = (Serializable) util.getIdentifier(entity);
-
- setObject(entity);
- }
-
- @Override
- protected T load() {
- T entity = null;
-
- if(identifier != null) {
- EntityManager entityManager = entityManagerFactory.createEntityManager();
- entity = entityManager.find(entityClass, identifier);
- }
- return entity;
- }
-
- @Override
- protected void onDetach() {
- super.onDetach();
-
- T entity = getObject();
- PersistenceUnitUtil persistenceUtil = entityManagerFactory.getPersistenceUnitUtil();
-
- if(entity == null) return;
-
- identifier = (Serializable) persistenceUtil.getIdentifier(entity);
- }
- }
-{code}
-
-The constructor of the model takes as input two parameters: an implementation of the JPA interface javax.persistence.EntityManagerFactory to manage JPA entities and the entity that must be handled by this model. Inside its constructor the model saves the class of the entity and its id (which could be null if the entity has not been persisted yet). These two informations are required to retrieve the entity at a later time and are used by the load method.
-
-onDetach is responsible for updating the entity id before detachment occurs. The id can change the first time an entity is persisted (JPA generates a new id and assigns it to the entity). Please note that this model is not responsible for saving any changes occurred to the entity object before it is detached. If we don't want to loose these changes we must explicitly persist the entity before the detaching phase occurs.
-
-{warning}
-Since the model of this example holds a reference to the EntityManager Factory, the implementation in use must be serializable.
-{warning}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_8.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_8.gdoc b/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_8.gdoc
deleted file mode 100644
index a34b7f5..0000000
--- a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_8.gdoc
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-Sometimes our custom components may need to use more than a single model to work properly. In such a case we must manually detach the additional models used by our components. In order to do this we can overwrite the Component's onDetach method that is called at the end of the current request. The following is the generic code of a component that uses two models:
-
-{code}
-/**
- *
- * fooModel is used as main model while beeModel must be manually detached
- *
- */
-public class ComponetTwoModels extends Component{
-
- private IModel<Bee> beeModel;
-
- public ComponetTwoModels(String id, IModel<Foo> fooModel, IModel<Bee> beeModel) {
- super(id, fooModel);
- this.beeModel = beeModel;
- }
-
- @Override
- public void onDetach() {
- if(beeModel != null)
- beeModel.detach();
-
- super.onDetach();
- }
-}
-{code}
-
-When we overwrite onDetach we must call the super class implementation of this method, usually as last line in our custom implementation.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_9.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_9.gdoc b/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_9.gdoc
deleted file mode 100644
index e19ac44..0000000
--- a/wicket-user-guide/src/docs/guide/modelsforms/modelsforms_9.gdoc
+++ /dev/null
@@ -1,22 +0,0 @@
-
-
-Like many people new to Wicket, you may need a little time to fully understand the power and the advantages of using models. Taking your first steps with Wicket you may be tempted to pass row objects to your components instead of using models:
-
-{code}
-/**
- *
- * NOT TO DO: passing row objects to components instead of using models!
- *
- */
-public class CustomComponent extends Component{
- private FooBean fooBean;
-
- public CustomComponent(String id, FooBean fooBean) {
- super(id);
- this.fooBean = fooBean;
- }
- //...some other ugly code :)...
-}
-{code}
-
-That's a bad practice and you must avoid it. Using models we do not only decouple our components from the data source, but we can also relay on them (if they are dynamic) to work with the most up-to-date version of our model object. If we decide to bypass models we lose all these advantages and we force model objects to be serialized.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/monitoring.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/monitoring.gdoc b/wicket-user-guide/src/docs/guide/monitoring.gdoc
deleted file mode 100644
index db39971..0000000
--- a/wicket-user-guide/src/docs/guide/monitoring.gdoc
+++ /dev/null
@@ -1,9 +0,0 @@
-The wicket-metrics module is available since Wicket 7.3.0 and contains a life measurement implementation to collect data of applications and visualize it.
-
-You can see how many request your application served, how often components are created, initalized, configured or their detach method has been invoked and a lot of other additional information.
-
-The module itself is using "Metrics of dropwizard":https://dropwizard.github.io/metrics/3.1.0/ and "AspectJ":https://eclipse.org/aspectj/ so that if you turn of the measurement it has no longer any effect
-
-to your web application.
-
-Keep in mind that AspectJ is licensed under the Eclipse Public License and you should provide the required license information.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/monitoring/monitoring_1.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/monitoring/monitoring_1.gdoc b/wicket-user-guide/src/docs/guide/monitoring/monitoring_1.gdoc
deleted file mode 100644
index 23065dd..0000000
--- a/wicket-user-guide/src/docs/guide/monitoring/monitoring_1.gdoc
+++ /dev/null
@@ -1,80 +0,0 @@
-This is a little example how to setup wicket-metrics within a Apache Tomcat.
-
-(1) Add the maven dependency to your project
-{code}
-<dependency>
- <groupId>org.apache.wicket.experimental.wicket8</groupId>
- <artifactId>wicket-metrics</artifactId>
- <version>0.X-SNAPSHOT</version>
-</dependency>
-{code}
-
-(2) Just drop the jars of aspectjrt and aspectjweaver into the tomcat lib folder - you can download it from here "http://mvnrepository.com/artifact/org.aspectj/":http://mvnrepository.com/artifact/org.aspectj/ (the metrics dependency is shipped with the project)
-
-(3) Add the java agent to the jvm start options of your tomcat: -javaagent:/pathToServer/lib/aspectjweaver-x.x.x.jar
-
-(4) Add an aop.xml to your project's META-INF folder at the root of your classpath with the metrics you want to use (aspect tags) - if you don't want to enable a metrics just remove the aspect tag:
-{code}
-<!DOCTYPE aspectj PUBLIC "-//AspectJ//DTD//EN" "http://www.eclipse.org/aspectj/dtd/aspectj.dtd">
-<aspectj>
- <weaver options="-nowarn">
- <include within="org.apache.wicket..*"/>
- </weaver>
- <aspects>
- <!-- required -->
- <aspect name="org.apache.wicket.metrics.aspects.WicketFilterInitAspect" />
-
- <!-- optional -->
- <aspect name="org.apache.wicket.metrics.aspects.model.LoadableDetachableModelLoadAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.requesthandler.IRequestHandlerDetachAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.requesthandler.IRequestHandlerRespondAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.resource.IResourceCreateAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.behavior.BehaviorCreateAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.component.ComponentCreateAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.component.ComponentOnConfigureAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.component.ComponentOnDetachAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.component.ComponentOnInitializeAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.component.ComponentOnRenderAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.component.ComponentSetResponsePageAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.ajax.IPartialPageRequestHandlerAddAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.ajax.IPartialPageRequestHandlerAppendJavaScriptAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.ajax.IPartialPageRequestHandlerPrependJavaScriptAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.resource.ResourceReferenceCreateAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.markup.WicketTagCreateAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.request.WicketFilterRequestCycleUrlAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.request.WicketFilterRequestCycleAspect" />
- <aspect name="org.apache.wicket.metrics.aspects.session.SessionCountListenerAspect" />
- </aspects>
-</aspectj>
-{code}
-
-* If you use the SessionCountListenerAspect you have to ensure that metadata-complete="false" is set otherwise you have to add the listener yourself:
-{code}
-<listener>
- <listener-class>
- org.apache.wicket.metrics.aspects.session.SessionCountListener
- </listener-class>
-</listener>
-{code}
-
-(5 - optional) To enable the JMX measurement write the following line into your init method of your Application (Now you are able to connect with jvisualvm to your server and have a look at the data):
-{code}
-WicketMetrics.getSettings().startJmxReporter();
-{code}
-
-To deactivate:
-{code}
-WicketMetrics.getSettings().stopJmxReporter();
-{code}
-
-To disable measurement:
-{code}
-WicketMetrics.getSettings().setEnabled(false);
-{code}
-
-*IMPORTANT INFORMATION*
-** It is only possible to collect metrics for *one wicket filter per webapp* - don't declare more then one if you want to use wicket-metrics
-** The WicketFilterInitAspect is required so that the application can be resolved - otherwise runtime exceptions will be thrown
-** If you use the SessionCountListener you have to clear the session store if you restart the server - otherwise physically stored session will corrupt the data, because the count is initialized with 0.
-** If you have set wicket-metrics as dependency you can open "wicket-metrics.template.xml" to get a full template of the "aop.xml"
-** For the weaver options refer to the AspectJ LTW configuration documentation: https://eclipse.org/aspectj/doc/next/devguide/ltw-configuration.html
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/monitoring/monitoring_2.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/monitoring/monitoring_2.gdoc b/wicket-user-guide/src/docs/guide/monitoring/monitoring_2.gdoc
deleted file mode 100644
index b6894ad..0000000
--- a/wicket-user-guide/src/docs/guide/monitoring/monitoring_2.gdoc
+++ /dev/null
@@ -1,86 +0,0 @@
-To visualize the metrics with Graphite a little additional configuration is required:
-
-(1) Add the additional maven dependency to your project:
-{code}
-<dependency>
- <groupId>io.dropwizard.metrics</groupId>
- <artifactId>metrics-graphite</artifactId>
- <version>${metrics.graphite.version}</version>
-</dependency>
-{code}
-
-* the metrics.graphite.version should be the same as the metrics version of the wicket-metrics dependency. Check the Maven dependencies to ensure
-this.
-
-(2) Add the following code to your Application's init method:
-{code}
- private GraphiteReporter reporter;
-
- @Override
- protected void init()
- {
- MetricRegistry metricRegistry = WicketMetrics.getMetricRegistry();
- final Graphite graphite = new Graphite(new InetSocketAddress("127.0.0.1", 2003));
- reporter = GraphiteReporter.forRegistry(metricRegistry).prefixedWith("WebApplications")
- .convertRatesTo(TimeUnit.SECONDS).convertDurationsTo(TimeUnit.MILLISECONDS)
- .filter(MetricFilter.ALL).build(graphite);
-
- // Collects data every 5 seconds
- reporter.start(5, TimeUnit.SECONDS);
- }
-
- @Override
- protected void onDestroy()
- {
- super.onDestroy();
- reporter.stop();
- }
-{code}
-
-(3) Install and setup graphite on your system. Example installation for Mac (beware that this is only a quickstart setup!):
-
-- (1) Install homebrew: "brew":http://brew.sh/
-
-- (2) Install "Git":https://git-scm.com/
-
-- (3) brew install python
-
-- (4) brew install cairo
-
-- (5) brew install py2cairo
-
-- (6) pip install Django==1.5
-
-- (7) pip install "django-tagging<0.4"
-
-- (8) sudo pip install carbon
-
-- (9) pip install whisper
-
-- (10) sudo pip install graphite-web
-
-- (11) sudo pip install Twisted==11.1.0
-
-- (12) sudo chown -R <your username>:staff /opt/graphite
-
-- (13) cp /opt/graphite/conf/carbon.conf{.example,}
-
-- (14) cp /opt/graphite/conf/storage-schemas.conf{.example,}
-
-- (15) cd /opt/graphite/webapp/graphite
-
-- (16) cp local_settings.py{.example,}
-
-- (17) python manage.py syncdb
-
-- (18) python /opt/graphite/bin/carbon-cache.py start
-
-- (19) python /opt/graphite/bin/run-graphite-devel-server.py /opt/graphite
-
-- (20) Go to http://localhost:8080
-
-* (18) and (19) have to be executed if the mac has been restarted
-
-(4) Now start your tomcat server configured like mentioned in the previous chapter.
-
-!wicket_metrics_graphite.png!
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/monitoring/monitoring_3.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/monitoring/monitoring_3.gdoc b/wicket-user-guide/src/docs/guide/monitoring/monitoring_3.gdoc
deleted file mode 100644
index 083c51f..0000000
--- a/wicket-user-guide/src/docs/guide/monitoring/monitoring_3.gdoc
+++ /dev/null
@@ -1,18 +0,0 @@
-The data which is going to be measured depends on the wicket-metrics implementation. So it doesn't make any sense to collect time data
-
-about setResponsePage, but it does for the constructor of components, to see if a component needs a long time to be created. You can
-
-get the information about which data has been collected from out of the mbeans.
-
-Here are some information about them:
-
-* max - the maximal time for a task (created, initialized, etc.)
-
-* min - the minimal time for a task (created, initialized, etc.)
-
-* count - how often something happened (request count)
-
-The structure is separated in the way that under core there are the kind of components measured and below that the type of operation
-
-(created, initialized, detached). In this category every component is listed dynamically.
-
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/monitoring/monitoring_4.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/monitoring/monitoring_4.gdoc b/wicket-user-guide/src/docs/guide/monitoring/monitoring_4.gdoc
deleted file mode 100644
index 22bdd3b..0000000
--- a/wicket-user-guide/src/docs/guide/monitoring/monitoring_4.gdoc
+++ /dev/null
@@ -1,38 +0,0 @@
-There are only a two steps required to write own measurements for life data statistics in Wicket:
-
-(1) Write a class which is named very close to what it measures. This class should extends WicketMetrics and should annotated with @Aspect and provide one method with a join point scanning for the target signature.
-{code}
- @Aspect
- public class MySpecialAspect extends WicketMetrics
- {
- @Around("execution(* my.package.MyClass.myMethod(..))")
- public Object aroundRequestProcessed(ProceedingJoinPoint joinPoint) throws Throwable
- {
- return measureTime("mycategory/someinformation/", joinPoint);
- }
- }
-{code}
-* To measure time you need @Around because measureTime of WicketMetrics requires the joinPoint - the class name is appended with a slash at the end
-
-* To only mark that a method is called you can use mark of WicketMetrics and apply null as a second parameter - if you apply a join point to mark the class name is appended with a slash at the end
-
-(2) Add the class to your aop.xml and of course the package to scan for classes that are target for your measurements:
-{code}
-<!DOCTYPE aspectj PUBLIC "-//AspectJ//DTD//EN" "http://www.eclipse.org/aspectj/dtd/aspectj.dtd">
-<aspectj>
- <weaver options="-nowarn">
- <include within="org.apache.wicket..*"/>
- <include within="my.components.package..*"/>
- </weaver>
- <aspects>
- <!-- required -->
- <aspect name="org.apache.wicket.metrics.aspects.WicketFilterInitAspect" />
-
- <!-- own aspects -->
- <aspect name="my.aspect.package.MySpecialAspect" />
-
- <!-- wickets own metrics -->
- .....
- </aspects>
-</aspectj>
-{code}
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/nativewebsockets.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/nativewebsockets.gdoc b/wicket-user-guide/src/docs/guide/nativewebsockets.gdoc
deleted file mode 100644
index 514f3db..0000000
--- a/wicket-user-guide/src/docs/guide/nativewebsockets.gdoc
+++ /dev/null
@@ -1,10 +0,0 @@
-[WebSockets|http://en.wikipedia.org/wiki/WebSocket] is a technology that provides full-duplex communications channels over a single TCP connection.
-This means that once the browser establish a web socket connection to the server the server can push data back to the browser without the browser explicitly asking again and again whether there is something new for it.
-
-Wicket Native WebSockets modules provide functionality to integrate with the non-standard APIs provided by different web containers (like [Apache Tomcat|http://tomcat.apache.org/] and [Jetty|http://www.eclipse.org/jetty/]) and standard [JSR356|https://www.jcp.org/en/jsr/detail?id=356] implementations.
-
-{warning}
-Native WebSocket works only when both the browser and the web containers support WebSocket technology. There are no plans to add support to fallback to long-polling, streaming or any other technology that simulates two way communication. Use it only if you really know that you will run your application in an environment that supports WebSockets.
-Currently supported web containers are Jetty 7.5+ , Tomcat 7.0.27+ and JBoss WildFly 8.0.0+.
-Supported browsers can be found at [caniuse.com|http://caniuse.com/#search=websocket].
-{warning}
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_1.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_1.gdoc b/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_1.gdoc
deleted file mode 100644
index 8a3b4fc..0000000
--- a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_1.gdoc
+++ /dev/null
@@ -1,7 +0,0 @@
-Each of the modules provide a specialization of @org.apache.wicket.protocol.http.WicketFilter@ that registers implementation specific endpoint when an HTTP request is [upgraded|http://en.wikipedia.org/wiki/WebSocket#WebSocket_protocol_handshake] to WebSocket one. Later Wicket uses this endpoint to write data back to the browser and read data sent by it.
-
-WebSockets communication can be used in a Wicket page by using @org.apache.wicket.protocol.ws.api.WebSocketBehavior@ or in a IResource by exteding @org.apache.wicket.protocol.ws.api.WebSocketResource@.
-When a client is connected it is being registered in a application scoped registry using as a key the application name, the client http session id, and the id of the page or the resource name that registered it. Later when the server needs to push a message it can use this registry to filter out which clients need to receive the message.
-
-When a message is received from the client Wicket wraps it in @IWebSocketMessage@ and calls WebSocketBehavior#*onMessage()* or WebSocketResource#*onMessage()* where the application logic can react on it.
-The server can push plain text and binary data to the client, but it can also add components for re-render, prepend/append JavaScript as it can do with [Ajax|guide:ajax].
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_2.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_2.gdoc b/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_2.gdoc
deleted file mode 100644
index 98bbb7d..0000000
--- a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_2.gdoc
+++ /dev/null
@@ -1,116 +0,0 @@
-* *Classpath dependency*
-
-Depending on the web container that is used the application has to add a dependency to either:
-
-- for Jetty 9.0.x
-{code}
-<dependency>
- <groupId>org.apache.wicket</groupId>
- <artifactId>wicket-native-websocket-jetty9</artifactId>
- <version>...</version>
-</dependency>
-{code}
-
-- for Tomcat 7.0.27+ (the old, non-JSR356 implementation)
-{code}
-<dependency>
- <groupId>org.apache.wicket</groupId>
- <artifactId>wicket-native-websocket-tomcat</artifactId>
- <version>...</version>
-</dependency>
-{code}
-
-- for JSR356 complaint implementations (at the moment are supported: Tomcat 8.0+, Tomcat 7.0.47+, Jetty 9.1.0+ and JBoss Wildfly 8.0.0+)
-{code}
-<dependency>
- <groupId>org.apache.wicket</groupId>
- <artifactId>wicket-native-websocket-javax</artifactId>
- <version>...</version>
-</dependency>
-{code}
-
-{note}
-All web containers providing JSR356 implementation are built with Java 7. This is the reason why @wicket-native-websocket-javax@ module is available only with Wicket 7.x+. If your application runs with JRE 7.x then you can
-use @wicket-native-websocket-javax@ together with the latest version of Wicket 6.x. Beware that the API/implementation of @wicket-native-websocket-javax@ may change before Wicket 7.0.0 is released!
-{note}
-
-{note}
-The examples above show snippets for Maven's pom.xml but the application can use any other dependency management tool like [Gradle|http://www.gradle.org/], [SBT|http://www.scala-sbt.org/], ...
-{note}
-
-* *web.xml*
-
-In @WEB-INF/web.xml@ replace the usage of *WicketFilter* with any of the following depending on the web container that is used:
-
-For Jetty 9.0.x:
-{code}
-<filter-class>org.apache.wicket.protocol.ws.jetty9.Jetty9WebSocketFilter</filter-class>
-{code}
-
-For Jetty 7.5+ and 8.x:
-{code}
-<filter-class>org.apache.wicket.protocol.ws.jetty7.Jetty7WebSocketFilter</filter-class>
-{code}
-
-For Tomcat 7.0.27+ (old implementation):
-{code}
-<filter-class>org.apache.wicket.protocol.ws.tomcat7.Tomcat7WebSocketFilter</filter-class>
-{code}
-
-For JSR356 complaint web containers (at the moment: Tomcat 7.0.47+, Tomcat 8.x and Jetty 9.1.x):
-{code}
-<filter-class>org.apache.wicket.protocol.ws.javax.JavaxWebSocketFilter</filter-class>
-{code}
-
-
-
-* *WebSocketBehavior*
-
-@org.apache.wicket.protocol.ws.api.WebSocketBehavior@ is similar to Wicket Ajax behaviors that you may have used.
-Add WebSocketBehavior to the page (or to any component in the page) that will use web socket communication:
-
-{code}
-public class MyPage extends WebPage {
-
- public MyPage()
- {
- add(new WebSocketBehavior() {
- @Override
- protected void onMessage(WebSocketRequestHandler handler, TextMessage message)
- {
- String msg = message.getText();
- // do something with msg
- }
- });
- }
-}
-{code}
-
-Use @message.getText()@ to read the message sent by the client and use @handler.push(String)@ to push a text message to the connected client. Additionally you can use @handler.add(Component...)@ to add Wicket components for re-render, @handler#prependJavaScript(CharSequence)@ and @handler#appendJavaScript(CharSequence)@ as you do with @AjaxRequestTarget@.
-
-* *WebSocketResource*
-
-Wicket allows one thread at a time to use a page instance to simplify the usage of the pages in multithreaded enviroment. When a WebSocket message is sent to a page Wicket needs to acquire the lock to that page to be able to pass the @IWebSocketMessage@ to the @WebSocketBehavior@. This may be problematic when the application needs to send many messages from the client to the server.
-For this reason Wicket provides @WebSocketResource@ - an IResource implemetation that provides the same APIs as @WebSocketBehavior@. The benefit is that there is no need of synchronization as with the pages and the drawback is that @WebSocketRequesthandler#add(Component...)@ method cannot be used because there is no access to the components in an @IResource@.
-
-To register such WebSocket resource add such line to @YourApplication#init()@ method:
-{code}
-getSharedResources().add("someName", new MyWebSocketResource());
-{code}
-
-and
-{code}
- page.add(new BaseWebSocketBehavior("someName"));
-{code}
-to any page. This will prepare the JavaScript connection for you.
-
-* *WebSocket connection registry*
-
-To push data to one or more clients the application can use the @IWebSocketConnectionRegistry@ to find all registered connections and send data to all/any of them:
-
-{code}
-Application application = Application.get(applicationName);
-WebSocketSettings webSocketSettings = WebSocketSettings.Holder.get(application);
-IWebSocketConnectionRegistry webSocketConnectionRegistry = webSocketSettings.getConnectionRegistry();
-IWebSocketConnection connection = webSocketConnectionRegistry.getConnection(application, sessionId, key);
-{code}
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_3.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_3.gdoc b/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_3.gdoc
deleted file mode 100644
index 512ea50..0000000
--- a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_3.gdoc
+++ /dev/null
@@ -1,29 +0,0 @@
-By adding a @(Base)WebSocketBehavior@ to your component(s) Wicket will contribute @wicket-websocket-jquery.js@ library which provides some helper functions to write your client side code. There is a default websocket connection per Wicket Page opened for you which you can use like:
-{code}
-Wicket.WebSocket.send('{msg: "my message"}').
-{code}
-
-To close the default connection:
-{code}
-Wicket.WebSocket.close()
-{code}
-
-Wicket.WebSocket is a simple wrapper around the native window.WebSocket API which is used to intercept the calls and to fire special JavaScript events (Wicket.Event PubSub).
-Once a page that contributes @(Base)WebSocketBehavior@ is rendered the client may react on messages pushed by the server by subscribing to the @'/websocket/message'@ event:
-
-{code}
-Wicket.Event.subscribe("/websocket/message", function(jqEvent, message) {
- var data = JSON.parse(message);
- processData(data); // does something with the pushed message
-});
-{code}
-
-Here is a table of all events that the application can subscribe to:
-{table}
-Event name | Arguments | Description
-/websocket/open | jqEvent | A WebSocket connection has been just opened
-/websocket/message | jqEvent, message | A message has been received from the server
-/websocket/closed | jqEvent | A WebSocket connection has been closed
-/websocket/error | jqEvent | An error occurred in the communication. The connection will be closed
-{table}
-
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_4.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_4.gdoc b/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_4.gdoc
deleted file mode 100644
index 98ba074..0000000
--- a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_4.gdoc
+++ /dev/null
@@ -1,2 +0,0 @@
-The module provides @org.apache.wicket.protocol.ws.util.tester.WebSocketTester@ which gives you the possibility to emulate sending and receiving messages without the need to run in a real web container, as WicketTester does this for HTTP requests.
-Check [WebSocketTesterBehaviorTest|https://github.com/apache/wicket/blob/master/wicket-native-websocket/wicket-native-websocket-core/src/test/java/org/apache/wicket/protocol/ws/util/tester/WebSocketTesterBehaviorTest.java?source=c] and [WebSocketTesterResourceTest|https://github.com/apache/wicket/blob/master/wicket-native-websocket/wicket-native-websocket-core/src/test/java/org/apache/wicket/protocol/ws/util/tester/WebSocketTesterResourceTest.java] for examples.
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_5.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_5.gdoc b/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_5.gdoc
deleted file mode 100644
index 52c1568..0000000
--- a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_5.gdoc
+++ /dev/null
@@ -1 +0,0 @@
-Wicket-Atmosphere experimental module provides integration with [Atmosphere|https://github.com/Atmosphere/atmosphere] and let it handle the inconsistencies in WebSocket protocol support in different browsers and web containers. If either the browser or the web container do not support WebSockets then Atmosphere will downgrade (depending on the configuration) to either long-polling, streaming, server-side events, jsonp, ... to simulate the long running connection.
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_6.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_6.gdoc b/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_6.gdoc
deleted file mode 100644
index 605c4ec..0000000
--- a/wicket-user-guide/src/docs/guide/nativewebsockets/nativewebsockets_6.gdoc
+++ /dev/null
@@ -1,2 +0,0 @@
-# Request and session scoped beans do not work.
-The Web Socket communication is not processed by Servlet Filters and Listeners and thus the Dependency Injection libraries have no chance to export the request and session bean proxies.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/redirects.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/redirects.gdoc b/wicket-user-guide/src/docs/guide/redirects.gdoc
deleted file mode 100644
index 4bc1604..0000000
--- a/wicket-user-guide/src/docs/guide/redirects.gdoc
+++ /dev/null
@@ -1,75 +0,0 @@
-Quite a few teams have already got stuck into the following problem when working with wicket forms in a clustered environment while having 2 (or more) tomcat server with enabled session replication running.
-
-In case of invalid data being submitted with a form instance for example, it seemed like according error messages wouldn\u2019t be presented when the same form page gets displayed again. Sometimes! And sometimes they would! One of those nightmares of rather deterministic programmer\u2019s life. This so called Lost In Redirection problem, even if it looks like a wicket bug at first, is rather a result of a default setting in wicket regarding the processing of form submissions in general. In order to prevent another wide known problem of double form submissions, Wicket uses a so called REDIRECT_TO_BUFFER strategy for dealing with rendering a page after web form\u2019s processing (@see RequestCycleSettings#RenderStrategy).
-
-What does the default RenderStrategy actually do?
-
-Both logical parts of a single HTTP request, an action and a render part get processed within the same request, but instead of streaming the render result to the browser directly, the result is cached on the server first.
-
-!lost-in-redirection-mockup.png!
-
-Wicket will create an according BufferedHttpServletResponse instance that will be used to cache the resulting HttpServletResponse within the WebApplication.
-
-!lost-in-redirection-mockup2.png!
-
-After the buffered response is cached the HTTP status code of 302 get\u2019s provided back to the browser resulting in an additional GET request to the redirect URL (which Wicket sets to the URL of the Form itself). There is a special handling code for this case in the WicketFilter instance that then looks up a Map of buffered responses within the WebApplication accordingly. If an appropriate already cached response for the current request is found, it get\u2019s streamed back to the browser immediately. No additional form processing happens now. The following is a code snippet taken from WicketFilter:
-
-{code}
-// Are we using REDIRECT_TO_BUFFER?
-if (webApplication.getRequestCycleSettings().getRenderStrategy() == RequestCycleSettings.REDIRECT_TO_BUFFER)
-{
- // Try to see if there is a redirect stored
- // try get an existing session
- ISessionStore sessionStore = webApplication.getSessionStore();
- String sessionId = sessionStore.getSessionId(request, false);
- if (sessionId != null)
- {
- BufferedHttpServletResponse bufferedResponse = null;
- String queryString = servletRequest.getQueryString();
- // look for buffered response
- if (!Strings.isEmpty(queryString))
- {
- bufferedResponse = webApplication.popBufferedResponse(sessionId,
- queryString);
- }
- else
- {
- bufferedResponse = webApplication.popBufferedResponse(sessionId,
- relativePath);
- }
- // if a buffered response was found
- if (bufferedResponse != null)
- {
- bufferedResponse.writeTo(servletResponse);
- // redirect responses are ignored for the request
- // logger...
- return true;
- }
- }
-}
-{code}
-
-So what happens in case you have 2 server running your application with session replication and load balancing turned on while using the default RenderStrategy described above?
-
-Since a Map of buffered responses is cached within a WebApplication instance that does not get replicated between the nodes obviously, a redirect request that is suppose to pick up the previously cached response (having possibly form violation messages inside) potentially get\u2019s directed to the second node in your cluster by the load balancer. The second node does not have any responses already prepared and cached for your user. The node therefore handles the request as a completely new request for the same form page and displays a fresh new form page instance to the user accordingly.
-
-!lost-in-redirection-mockup3.png!
-
-Unfortunately, there is currently no ideal solution to the problem described above. The default RenderStrategy used by Apache Wicket simply does not work well in a fully clustered environment with load balancing and session replication turned on. One possibility is to change the default render strategy for your application to a so called ONE_PASS_RENDER RenderStrategy which is the more suitable option to use when you want to do sophisticated (non-sticky session) clustering. This is easily done in the init method of your own subclass of Wicket\u2019s WebApplication :
-
-{code}
-@Override
-protected void init() {
- getRequestCycleSettings().setRenderStrategy(
- RequestCycleSettings.ONE_PASS_RENDER);
-}
-{code}
-
-ONE_PASS_RENDER RenderStrategy does not solve the double submit problem though! So this way you\u2019d only be trading one problem for another one actually.
-
-You could of course turn on the session stickiness between your load balancer (apache server) and your tomcat server additionally to the session replication which would be the preferred solution in my opinion.
-
-!lost-in-redirection-mockup4.png!
-
-Session replication would still provide you with failover in case one of the tomcat server dies for whatever reason and sticky sessions would ensure that the Lost In Redirection problem does not occur any more.
-
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/repeaters.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/repeaters.gdoc b/wicket-user-guide/src/docs/guide/repeaters.gdoc
deleted file mode 100644
index 21e6c3a..0000000
--- a/wicket-user-guide/src/docs/guide/repeaters.gdoc
+++ /dev/null
@@ -1,22 +0,0 @@
-A common task for web applications is to display a set of items. The most typical scenario where we need such kind of visualization is when we have to display some kind of search result. With the old template-based technologies (like JSP) we used to accomplish this task using classic for or while loops:
-
-{code:html}
-<html>
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
-<title>Insert title here</title>
-</head>
-<body>
- <%
- for(int i = 12; i<=32; i++) {
- %>
- <div>Hello! I'm index n�<%= %></div>
- <%
- }
- %>
-</body>
-{code}
-
-To ease this task Wicket provides a number of special-purpose components called repeaters which are designed to use their related markup to display the items of a given set in a more natural and less chaotic way.
-
-In this chapter we will see some of the built-in repeaters that come with Wicket.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/repeaters/repeaters_1.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/repeaters/repeaters_1.gdoc b/wicket-user-guide/src/docs/guide/repeaters/repeaters_1.gdoc
deleted file mode 100644
index 7f636a8..0000000
--- a/wicket-user-guide/src/docs/guide/repeaters/repeaters_1.gdoc
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-Component @org.apache.wicket.markup.repeater.RepeatingView@ is a container which renders its children components using the tag it is bound to. It can contain an arbitrary number of children elements and we can obtain a new valid id for a new child calling its method newChildId(). This component is particularly suited when we have to repeat a simple markup fragment, for example when we want to display some items as a HTML list:
-
-*HTML:*
-{code:html}
-<ul>
- <li wicket:id="listItems"></li>
-</ul>
-{code}
-
-*Java Code:*
-{code}
-RepeatingView listItems = new RepeatingView("listItems");
-
-listItems.add(new Label(listItems.newChildId(), "green"));
-listItems.add(new Label(listItems.newChildId(), "blue"));
-listItems.add(new Label(listItems.newChildId(), "red"));
-{code}
-
-*Generated markup:*
-{code:html}
-<ul>
- <li>green</li>
- <li>blue</li>
- <li>red</li>
-</ul>
-{code}
-
-As we can see in this example, each child component has been rendered using the parent markup as if it was its own.
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/repeaters/repeaters_2.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/repeaters/repeaters_2.gdoc b/wicket-user-guide/src/docs/guide/repeaters/repeaters_2.gdoc
deleted file mode 100644
index c3bcc71..0000000
--- a/wicket-user-guide/src/docs/guide/repeaters/repeaters_2.gdoc
+++ /dev/null
@@ -1,48 +0,0 @@
-
-
-As its name suggests, component @org.apache.wicket.markup.html.list.ListView@ is designed to display a given list of objects which can be provided as a standard Java List or as a model containing the concrete List. ListView iterates over the list and creates a child component of type @org.apache.wicket.markup.html.list.ListItem@ for every encountered item.
-
-Unlike RepeatingView this component is intended to be used with complex markup fragments containing nested components.
-
-To generate its children, ListView calls its abstract method populateItem(ListItem<T> item) for each item in the list, so we must provide an implementation of this method to tell the component how to create its children components. In the following example we use a ListView to display a list of Person objects:
-
-*HTML:*
-{code:html}
-...
- <body>
- <div id="bd" style="display: table;">
- <div wicket:id="persons" style="display: table-row;">
- <div style="display: table-cell;"><b>Full name: </b></div>
- <div wicket:id="fullName" style="display: table-cell;"></div>
- </div>
- </div>
- </body>
-...
-{code}
-
-*Java Code (Page Constructor):*
-{code}
-public HomePage(final PageParameters parameters) {
- List<Person> persons = Arrays.asList(new Person("John", "Smith"),
- new Person("Dan", "Wong"));
-
- add(new ListView<Person>("persons", persons) {
- @Override
- protected void populateItem(ListItem<Person> item) {
- item.add(new Label("fullName", new PropertyModel(item.getModel(), "fullName")));
- }
- });
-}
-{code}
-
-*Screenshot of generated page:*
-
-!simple-listview-screenshot.png!
-
-In this example we have displayed the full name of two Person's instances. The most interesting part of the code is the implementation of method populateItem where parameter item is the current child component created by ListView and its model contains the corresponding element of the list. Please note that inside populateItem we must add nested components to the @item@ object and not directly to the @ListView@.
-
-h3. ListView and Form
-
-By default @ListView@ replaces its children components with new instances every time is rendered. Unfortunately this behavior is a problem if @ListView@ is inside a form and it contains form components. The problem is caused by the fact that children components are replaced by new ones before form is rendered, hence they can't keep their input value if validation fails and, furthermore, their feedback messages can not be displayed.
-
-To avoid this kind of problem we can force @ListView@ to reuse its children components using its method setReuseItems and passing true as parameter. If for any reason we need to refresh children components after we have invoked setReuseItems(true), we can use MarkupContainer's method @removeAll()@ to force @ListView@ to rebuild them.
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/repeaters/repeaters_3.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/repeaters/repeaters_3.gdoc b/wicket-user-guide/src/docs/guide/repeaters/repeaters_3.gdoc
deleted file mode 100644
index 5ad775f..0000000
--- a/wicket-user-guide/src/docs/guide/repeaters/repeaters_3.gdoc
+++ /dev/null
@@ -1,50 +0,0 @@
-
-
-Component @org.apache.wicket.markup.repeater.RefreshingView@ is a subclass of RepeatingView that comes with a customizable rendering strategy for its children components.
-
-RefreshingView defines abstract methods populateItem(Item) and getItemModels(). The first method is similar to the namesake method seen for ListView, but it takes in input an instance of class @org.apache.wicket.markup.repeater.Item@ which is a subclass of @ListItem@. RefreshingView is designed to display a collection of models containing the actual items. An iterator over these models is returned by the other abstract method getItemModels.
-
-The following code is a version of the previous example that uses @RefreshingView@ in place of @ListView@:
-
-*HTML:*
-{code:html}
-...
- <body>
- <div id="bd" style="display: table;">
- <div wicket:id="persons" style="display: table-row;">
- <div style="display: table-cell;"><b>Full name: </b></div>
- <div wicket:id="fullName" style="display: table-cell;"></div>
- </div>
- </div>
- </body>
-...
-{code}
-
-*Java Code (Page Constructor):*
-{code}
-public HomePage(final PageParameters parameters) {
- //define the list of models to use
- final List<IModel<Person>> persons = new ArrayList<IModel<Person>>();
-
- persons.add(Model.of(new Person("John", "Smith")));
- persons.add(Model.of(new Person("Dan", "Wong")));
-
- add(new RefreshingView<Person>("persons") {
- @Override
- protected void populateItem(Item<Person> item) {
- item.add(new Label("fullName", new PropertyModel(item.getModel(), "fullName")));
- }
-
- @Override
- protected Iterator<IModel<Person>> getItemModels() {
- return persons.iterator();
- }
- });
-}
-{code}
-
-h3. Item reuse strategy
-
-Similar to @ListView@, the default behavior of the @RefreshingView@ is to replace its children with new instances every time is rendered. The strategy that decides if and how children components must be refreshed is returned by method @getItemReuseStrategy@. This strategy is an implementation of interface IItemReuseStrategy. The default implementation used by @RefreshingView@ is class @DefaultItemReuseStrategy@ but Wicket provides also strategy @ReuseIfModelsEqualStrategy@ which reuses an item if its model has been returned by the iterator obtained with method @getItemModels@.
-
-To set a custom strategy we must use method @setItemReuseStrategy@.
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/repeaters/repeaters_4.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/repeaters/repeaters_4.gdoc b/wicket-user-guide/src/docs/guide/repeaters/repeaters_4.gdoc
deleted file mode 100644
index 946ea09..0000000
--- a/wicket-user-guide/src/docs/guide/repeaters/repeaters_4.gdoc
+++ /dev/null
@@ -1,112 +0,0 @@
-
-
-Wicket offers a number of components that should be used when we have to display a big number of items (for example the results of a select SQL query).
-
-All these components implement interface @org.apache.wicket.markup.html.navigation.paging.IPageable@ and use interface @IDataProvider@ (placed in package @org.apache.wicket.markup.repeater.data@) as data source. This interface is designed to support data paging. We will see an example of data paging later in [paragraph 13.4.2|guide:repeaters_4].
-
-The methods defined by IDataProvider are the following:
-* iterator(long first, long count): returns an iterator over a subset of the entire dataset. The subset starts from the item at position first and includes all the next count items (i.e. it's the closed interval [first,first+count]).
-* size(): gets the size of the entire dataset.
-* model(T object): this method is used to wrap an item returned by the iterator with a model. This can be necessary if, for example, we need to wrap items with a detachable model to prevent them from being serialized.
-
-Wicket already provides implementations of IDataProvider to work with a List as data source (ListDataProvider) and to support data sorting (SortableDataProvider).
-
-h3. Component DataView
-
-Class @org.apache.wicket.markup.repeater.data.DataView@ is the simplest pageable repeater shipped with Wicket. DataView comes with abstract method populateItem(Item) that must be implemented to configure children components. In the following example we use a DataView to display a list of Person objects in a HTML table:
-
-*HTML:*
-{code:html}
-<table>
- <tr>
- <th>Name</th><th>Surename</th><th>Address</th><th>Email</th>
- </tr>
- <tr wicket:id="rows">
- <td wicket:id="dataRow"></td>
- </tr>
-</table>
-{code}
-
-*Java Code:*
-{code}
-//method loadPersons is defined elsewhere
-List<Person> persons = loadPersons();
-ListDataProvider<Person> listDataProvider = new ListDataProvider<Person>(persons);
-
-DataView<Person> dataView = new DataView<Person>("rows", listDataProvider) {
-
- @Override
- protected void populateItem(Item<Person> item) {
- Person person = item.getModelObject();
- RepeatingView repeatingView = new RepeatingView("dataRow");
-
- repeatingView.add(new Label(repeatingView.newChildId(), person.getName()));
- repeatingView.add(new Label(repeatingView.newChildId(), person.getSurename()));
- repeatingView.add(new Label(repeatingView.newChildId(), person.getAddress()));
- repeatingView.add(new Label(repeatingView.newChildId(), person.getEmail()));
- item.add(repeatingView);
- }
-};
-add(dataView);
-{code}
-
-Please note that in the code above we have used also a RepeatingView component to populate the rows of the table.
-
-In the next paragraph we will see a similar example that adds support for data paging.
-
-h3. Data paging
-
-To enable data paging on a pageable repeater, we must first set the number of items to display per page with method setItemsPerPage(long items). Then, we must attach the repeater to panel PagingNavigator (placed in package @org.apache.wicket.markup.html.navigation.paging@) which is responsible for rendering a navigation bar containing the links illustrated in the following picture:
-
-!paging-navigator.png!
-
-Project PageDataViewExample mixes a DataView component with a PagingNavigator to display the list of all countries of the world sorted by alphabetical order. Here is the initialization code of the project home page:
-
-*HTML:*
-{code:html}
-<table>
- <tr>
- <th>ISO 3166-1</th><th>Name</th><th>Long name</th><th>Capital</th><th>Population</th>
- </tr>
- <tr wicket:id="rows">
- <td wicket:id="dataRow"></td>
- </tr>
-</table>
-{code}
-
-*Java Code:*
-{code}
-public HomePage(final PageParameters parameters) {
- super(parameters);
- //method loadCountriesFromCsv is defined elsewhere in the class.
- //It reads countries data from a csv file and returns each row as an array of Strings.
- List<String[]> countries = loadCountriesFromCsv();
- ListDataProvider<String[]> listDataProvider = new ListDataProvider<String[]>(countries);
-
- DataView<String[]> dataView = new DataView<String[]>("rows", listDataProvider) {
- @Override
- protected void populateItem(Item<String[]> item) {
- String[] countriesArr = item.getModelObject();
- RepeatingView repeatingView = new RepeatingView("dataRow");
-
- for (int i = 0; i < countriesArr.length; i++){
- repeatingView.add(new Label(repeatingView.newChildId(), countriesArr[i]));
- }
- item.add(repeatingView);
- }
- };
-
- dataView.setItemsPerPage(15);
-
- add(dataView);
- add(new PagingNavigator("pagingNavigator", dataView));
-}
-{code}
-
-The data of a single country (ISO code, name, long name, capital and population) are handled with an array of strings. The usage of PagingNavigator is quite straightforward as we need to simply pass the pageable repeater to its constructor.
-
-To explore the other pageable repeaters shipped with Wicket you can visit the page at {externalink:wicket.examples.url@repeater} where you can find live examples of these components.
-
-{note}
-Wicket provides also component PageableListView which is a sublcass of ListView that implements interface IPageable, hence it can be considered a pageable repeater even if it doesn't use interface IDataProvider as data source.
-{note}
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/repeaters/repeaters_5.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/repeaters/repeaters_5.gdoc b/wicket-user-guide/src/docs/guide/repeaters/repeaters_5.gdoc
deleted file mode 100644
index b81cf0b..0000000
--- a/wicket-user-guide/src/docs/guide/repeaters/repeaters_5.gdoc
+++ /dev/null
@@ -1,7 +0,0 @@
-
-
-In this chapter we have explored the built-in set of components called repeaters which are designed to repeat their own markup in output to display a set of items. We have started with component @RepeatingView@ which can be used to repeat a simple markup fragment.
-
-Then, we have seen components @ListView@ and @RefreshingView@ which should be used when the markup to repeat contains nested components to populate.
-
-Finally, we have discussed those repeaters that support data paging and that are called pageable repeaters. We ended the chapter looking at an example where a pageable repeater is used with panel PagingNavigator to make its dataset navigable by the user.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/requestProcessing.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/requestProcessing.gdoc b/wicket-user-guide/src/docs/guide/requestProcessing.gdoc
deleted file mode 100644
index d5e22b7..0000000
--- a/wicket-user-guide/src/docs/guide/requestProcessing.gdoc
+++ /dev/null
@@ -1,4 +0,0 @@
-Although Wicket was born to provide a reliable and comprehensive object oriented abstraction for web development, sometimes we might need to work directly with \u201craw\u201d web entities such as user session, web request, query parameters, and so on. For example this is necessary if we want to store an arbitrary parameter in the user session.
-
-Wicket provides wrapper classes that allow us to easily access to web entities without the burden of using the low-level APIs of Java Servlet Specification. However it will always be possible to access standard classes (like HttpSession, HttpServletRequest, etc...) that lay under our Wicket application.
-This chapter will introduce these wrapper classes and it will explain how Wicket uses them to handle the web requests initiated by the user's browser.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/requestProcessing/requestProcessing_1.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/requestProcessing/requestProcessing_1.gdoc b/wicket-user-guide/src/docs/guide/requestProcessing/requestProcessing_1.gdoc
deleted file mode 100644
index b8d64c9..0000000
--- a/wicket-user-guide/src/docs/guide/requestProcessing/requestProcessing_1.gdoc
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
-Beside configuring and initializing our application, the Application class is responsible for creating the internal entities used by Wicket to process a request. These entities are instances of the following classes: RequestCycle, Request, Response and Session.
-
-The next paragraphs will illustrate each of these classes, explaining how they are involved into request processing.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/533c2d36/wicket-user-guide/src/docs/guide/requestProcessing/requestProcessing_2.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/requestProcessing/requestProcessing_2.gdoc b/wicket-user-guide/src/docs/guide/requestProcessing/requestProcessing_2.gdoc
deleted file mode 100644
index f211513..0000000
--- a/wicket-user-guide/src/docs/guide/requestProcessing/requestProcessing_2.gdoc
+++ /dev/null
@@ -1,5 +0,0 @@
-
-
-The @Request@ and @Response@ classes are located in package @org.apache.wicket.request@ and they provide an abstraction of the concrete request and response used by our web application.
-
-Both classes are declared as abstract but if our application class inherits from @WebApplication@ it will use their sub classes @ServletWebRequest@ and @ServletWebResponse@, both of them located inside the package @org.apache.wicket.protocol.http.servlet.ServletWebRequest@ and @ServletWebResponse@ wrap respectively a @HttpServletRequest@ and a @HttpServletResponse@ object. If we need to access to these low-level objects we can call @Request@'s method @getContainerRequest()@ and @Response@'s method @getContainerResponse()@.
\ No newline at end of file