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/23 22:44:51 UTC
[18/22] wicket git commit: Moved wicket-7.x docs to asciidoctor
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/forms2/forms2_5.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/forms2/forms2_5.gdoc b/wicket-user-guide/src/docs/guide/forms2/forms2_5.gdoc
deleted file mode 100644
index f5869b4..0000000
--- a/wicket-user-guide/src/docs/guide/forms2/forms2_5.gdoc
+++ /dev/null
@@ -1,124 +0,0 @@
-
-
-Besides submitting forms with a standard HTML submit button, Wicket allows us to use special components which implement interface IFormSubmittingComponent. This entity is a subinterface of IFormSubmitter:
-
-!class-diag-IFormSubmittingComponent.png!
-
-At the beginning of this chapter we have seen that form processing is started by process method which takes as input an instance of IFormSubmitter. This parameter corresponds to the IFormSubmittingComponent clicked by a user to submit the form and it is null if we have used a standard HTML submit button (like we have done so far).
-
-A submitting component is added to a form just like any other child component using method add(Component...).
-
-A form can have any number of submitting components and we can specify which one among them is the default one by calling the Form's method setDefaultButton(IFormSubmittingComponent �component). The default submitter is the one that will be used when user presses 'Enter' key in a field of the form. In order to make the default button work, Wicket will add to our form a hidden <div> tag containing a text field and a submit button with some JavaScript code to trigger it:
-
-{code:html}
-<div style="width:0px;height:0px;position:absolute;left:-100px;top:-100px;overflow:hidden">
- <input type="text" autocomplete="off"/>
- <input type="submit" name="submit2" onclick=" var b=document...."/>
-</div>
-{code}
-
-Just like Wicket forms, interface IFormSubmitter defines methods onSubmit and onError. These two methods have the priority over the namesake methods of the form, meaning that when a form is submitted with an IFormSubmitter, the onSubmit of the submitter is called before the one of the form. Similarly, if validation errors occurs during the first step of form processing, submitter's method onError is called before the form's one.
-
-{note}
-Starting with Wicket version 6.0 interface IFormSubmitter defines a further callback method called onAfterSubmit(). This method is called after form's method onSubmit() has been executed.
-{note}
-
-h3. Components Button and SubmitLink
-
-Component @org.apache.wicket.markup.html.form.Button@ is a basic implementation of a form submitter. It can be used with either the <input> or <button> tags. The string model received as input by its constructor is used as button label and it will be the value of the markup attribute value.
-
-In the following snippet we have a form with two submit buttons bound to an <input> tag. One of them is set as default button and both have a string model for the label:
-
-*HTML:*
-
-{code:html}
-<body>
- <form wicket:id="form">
- Username: <input type="text" wicket:id="username"/>
- <br/>
- <input type="submit" wicket:id="submit1"/>
- <input type="submit" wicket:id="submit2"/>
- </form>
-</body>
-{code}
-
-*Java code:*
-
-{code}
-public class HomePage extends WebPage {
-
- public HomePage(final PageParameters parameters) {
- Form form = new Form("form");
-
- form.add(new TextField("username", Model.of("")));
- form.add(new Button("submit1", Model.of("First submitter")));
- Button secondSubmitter;
- form.add(secondSubmitter = new Button("submit2", Model.of("Second submitter")));
-
- form.setDefaultButton(secondSubmitter);
- add(form);
- }
-}
-{code}
-
-*Generated markup:*
-
-{code:html}
-<form wicket:id="form" id="form1" method="post" action="?0-1.IFormSubmitListener-form">
- <div>
- ...
- <!-- Code generated by Wicket to handle the default button -->
- ...
- </div>
- Username: <input type="text" wicket:id="username" value="" name="username"/>
- <br/>
- <input type="submit" wicket:id="submit1" name="submit1" id="submit13" value="First submitter"/>
- <input type="submit" wicket:id="submit2" name="submit2" id="submit22" value="Second submitter"/>
-</form>
-{code}
-
-Another component that can be used to submit a form is @org.apache.wicket.markup.html.form.SubmitLink@. This component uses JavaScript to submit the form. Like the name suggests, the component can be used with the <a> tag but it can be also bound to any other tag that supports the event handler onclick. When used with the <a> tag, the JavaScript code needed to submit the form will be placed inside href attribute while with other tags the script will go inside the event handler onclick.
-
-A notable difference between this component and Button is that SubmitLink can be placed outside the form it must submit. In this case we must specify the form to submit in its constructor:
-
-*HTML:*
-
-{code:html}
-<html xmlns:wicket="http://wicket.apache.org">
- <head>
- </head>
- <body>
- <form wicket:id="form">
- Password: <input type="password" wicket:id="password"/>
- <br/>
- </form>
- <button wicket:id="externalSubmitter">
- Submit
- </button>
- </body>
-</html>
-{code}
-
-*Java code:*
-
-{code}
-public class HomePage extends WebPage {
-
- public HomePage(final PageParameters parameters) {
- Form form = new Form("form");
-
- form.add(new PasswordTextField("password", Model.of("")));
- //specify the form to submit
- add(new SubmitLink("externalSubmitter", form));
- add(form);
- }
-}
-{code}
-
-h3. Disabling default form processing
-
-With an IFormSubmittingComponent we can choose to skip the default form submission process by setting the appropriate flag to false with the setDefaultFormProcessing method. When the default form processing is disabled only the submitter's onSubmit is called while form's validation and models updating are skipped.
-
-This can be useful if we want to implement a \u201cCancel\u201d button on our form which redirects user to another page without validating his/her input.
-
-When we set this flag to false we can decide to manually invoke the form processing by calling the process(IFormSubmittingComponent) method.
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/forms2/forms2_6.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/forms2/forms2_6.gdoc b/wicket-user-guide/src/docs/guide/forms2/forms2_6.gdoc
deleted file mode 100644
index 3fb1ab7..0000000
--- a/wicket-user-guide/src/docs/guide/forms2/forms2_6.gdoc
+++ /dev/null
@@ -1,22 +0,0 @@
-
-
-As you might already known, HTLM doesn't allow to have nested forms. However with Wicket we can overcome this limitation by adding one or more form components to a parent form.
-
-This can be useful if we want to split a big form into smaller ones in order to reuse them and to better distribute responsibilities among different components.
-Forms can be nested to an arbitrary level:
-
-{code:html}
-<form wicket:id="outerForm">
- ...
- <form wicket:id="innerForm">
- ...
- <form wicket:id="veryInnerForm">
- ...
- </form>
- </form>
-</form>
-{code}
-
-When a form is submitted also its nested forms are submitted and they participate in the validation step. This means that if a nested form contains invalid input values, the outer form won't be submitted. On the contrary, nested forms can be singularly submitted without depending on the status of their outer form.
-
-To submit a parent form when one of its children forms is submitted, we must override its method wantSubmitOnNestedFormSubmit and make it return true.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/forms2/forms2_7.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/forms2/forms2_7.gdoc b/wicket-user-guide/src/docs/guide/forms2/forms2_7.gdoc
deleted file mode 100644
index d293a4a..0000000
--- a/wicket-user-guide/src/docs/guide/forms2/forms2_7.gdoc
+++ /dev/null
@@ -1,17 +0,0 @@
-
-
-HTML provides a multi-line text input control with <textarea> tag. The Wicket counterpart for this kind of control is @org.apache.wicket.markup.html.form.TextArea@ component:
-
-*HTML:*
-
-{code:html}
-<textarea wicket:id="description" rows="5" cols="40"></textarea>
-{code}
-
-*Java code:*
-
-{code}
-form.add(new TextArea("description", Model.of("")));
-{code}
-
-Component TextArea is used just like any other single-line text field. To specify the size of the text area we can write attributes rows and cols directly in the markup file or we can create new attribute modifiers and add them to our TextArea component.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/forms2/forms2_8.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/forms2/forms2_8.gdoc b/wicket-user-guide/src/docs/guide/forms2/forms2_8.gdoc
deleted file mode 100644
index 8d9cc20..0000000
--- a/wicket-user-guide/src/docs/guide/forms2/forms2_8.gdoc
+++ /dev/null
@@ -1,81 +0,0 @@
-
-
-Wicket supports file uploading with the FileUploadField component which must be used with the <input> tag whose type attribute must be set to "file". In order to send a file on form submission we must enable multipart mode calling MultiPart(true)on our form.
-
-In the next example (project UploadSingleFile) we will see a form which allows users to upload a file into the temporary directory of the server (path /tmp on Unix/Linux systems):
-
-*HTML:*
-
-{code:html}
-<html>
- <head>
- </head>
- <body>
- <h1>Upload your file here!</h1>
- <form wicket:id="form">
- <input type="file" wicket:id="fileUploadField"/>
- <input type="submit" value="Upload"/>
- </form>
- <div wicket:id="feedbackPanel">
- </div>
- </body>
-</html>
-{code}
-
-*Java code:*
-
-{code}
-public class HomePage extends WebPage {
- private FileUploadField fileUploadField;
-
- public HomePage(final PageParameters parameters) {
- fileUploadField = new FileUploadField("fileUploadField");
-
- Form form = new Form("form"){
- @Override
- protected void onSubmit() {
- super.onSubmit();
-
- FileUpload fileUpload = fileUploadField.getFileUpload();
-
- try {
- File file = new File(System.getProperty("java.io.tmpdir") + "/" +
- fileUpload.getClientFileName());
-
- fileUpload.writeTo(file);
- } catch (IOException e) {
- e.printStackTrace();
- }
- }
- };
-
- form.setMultiPart(true);
- //set a limit for uploaded file's size
- form.setMaxSize(Bytes.kilobytes(100));
- form.add(fileUploadField);
- add(new FeedbackPanel("feedbackPanel"));
- add(form);
- }
-}
-{code}
-
-The code that copies the uploaded file to the temporary directory is inside the onSubmit method of the Form class. The uploaded file is handled with an instance of class FileUpload returned by the getFileUpload() method of the FileUploadField class. This class provides a set of methods to perform some common tasks like getting the name of the uploaded file (getClientFileName()), coping the file into a directory (writeTo(destinationFile)), calculating file digest (getDigest (digestAlgorithm)) and so on.
-
-Form component can limit the size for uploaded files using its setMaxSize(size) method. In the example we have set this limit to 100 kb to prevent users from uploading files bigger than this size.
-
-{note}
-The maximum size for uploaded files can also be set at application's level using the setDefaultMaximumUploadSize(Bytes maxSize) method of class ApplicationSettings:
-
-{code}
-@Override
-public void init()
-{
- getApplicationSettings().setDefaultMaximumUploadSize(Bytes.kilobytes(100));
-}
-{code}
-{note}
-
-h3. Upload multiple files
-
-If we need to upload multiple files at once and our clients support HTML5, we can still use FileUploadField adding attribute "multiple" to its tag. If we can not rely on HTML5, we can use the MultiFileUploadField component which allows the user to upload an arbitrary number of files using a JavaScript-based solution.
-An example showing how to use this component can be found in Wicket module wicket-examples in file MultiUploadPage.java. The live example is hosted at {externalink:wicket.examples.url@upload/multi} .
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/forms2/forms2_9.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/forms2/forms2_9.gdoc b/wicket-user-guide/src/docs/guide/forms2/forms2_9.gdoc
deleted file mode 100644
index aa95cf6..0000000
--- a/wicket-user-guide/src/docs/guide/forms2/forms2_9.gdoc
+++ /dev/null
@@ -1,122 +0,0 @@
-
-
-In [chapter 5.2.2|guide:layout_2] we have seen how to use class Panel to create custom components with their own markup and with an arbitrary number of children components.
-
-While it's perfectly legal to use Panel also to group form components, the resulting component won't be itself a form component and it won't participate in the form's submission workflow.
-
-This could be a strong limitation if the custom component needs to coordinate its children during sub-tasks like input conversion or model updating. That's why in Wicket we have the @org.apache.wicket.markup.html.form.FormComponentPanel@ component which combines the features of a Panel (it has its own markup file) and a FormComponent (it is a subclass of FormComponent).
-
-A typical scenario in which we may need to implement a custom FormComponentPanel is when our web application and its users work with different units of measurement for the same data.
-
-To illustrate this possible scenario, let's consider a form where a user can insert a temperature that will be recorded after being converted to Kelvin degrees (see the example project CustomForm ComponentPanel).
-
-The Kelvin scale is wildly adopted among the scientific community and it is one of the seven base units of the "International System of Units":http://en.wikipedia.org/wiki/International_System_of_Units , so it makes perfect sense to store temperatures expressed with this unit of measurement.
-
-However, in our everyday life we still use other temperature scales like Celsius or Fahrenheit, so it would be nice to have a component which internally works with Kelvin degrees and automatically applies conversion between Kelvin temperature scale and the one adopted by the user.
-
-In order to implement such a component, we can make a subclass of FormComponentPanel and leverage the convertInput and onBeforeRender methods: in the implementation of the convertInput method we will convert input value to Kelvin degrees while in the implementation of onBeforeRender method we will take care of converting the Kelvin value to the temperature scale adopted by the user.
-
-Our custom component will contain two children components: a text field to let user insert and edit a temperature value and a label to display the letter corresponding to user's temperature scale (F for Fahrenheit and C for Celsius). The resulting markup file is the following:
-
-{code:html}
-<html>
-<head>
-</head>
-<body>
- <wicket:panel>
- Registered temperature: <input size="3" maxlength="3"
- wicket:id="registeredTemperature"/>
- <label wicket:id="mesuramentUnit"></label>
- </wicket:panel>
-</body>
-</html>
-{code}
-
-As shown in the markup above FormComponentPanel uses the same <wicket:panel> tag used by Panel to define its markup. Now let's see the Java code of the new form component starting with the onInitialize() method:
-
-{code}
-public class TemperatureDegreeField extends FormComponentPanel<Double> {
-
- private TextField<Double> userDegree;
-
- public TemperatureDegreeField(String id) {
- super(id);
- }
-
- public TemperatureDegreeField(String id, IModel<Double> model) {
- super(id, model);
- }
-
- @Override
- protected void onInitialize() {
- super.onInitialize();
-
- AbstractReadOnlyModel<String> labelModel=new AbstractReadOnlyModel<String>(){
- @Override
- public String getObject() {
- if(getLocale().equals(Locale.US))
- return "�F";
- return "�C";
- }
- };
-
- add(new Label("mesuramentUnit", labelModel));
- add(userDegree=new TextField<Double>("registeredTemperature", new
- Model<Double>()));
- userDegree.setType(Double.class);
- }
-{code}
-
-Inside the onInitialize method we have created a read-only model for the label that displays the letter corresponding to the user's temperature scale. To determinate which temperature scale is in use, we retrieve the Locale from the session by calling Component's getLocale() method (we will talk more about this method in [paragraph 15|guide:i18n]). Then, if locale is the one corresponding to the United States, the chosen scale will be Fahrenheit, otherwise it will be considered as Celsius.
-
-In the final part of onInitialize() we add the two components to our custom form component. You may have noticed that we have explicitly set the type of model object for the text field to double. This is necessary as the starting model object is a null reference and this prevents the component from automatically determining the type of its model object.
-
-Now we can look at the rest of the code containing the convertInput and onBeforeRender methods:
-
-{code}
-// continued example
- @Override
- protected void convertInput() {
- Double userDegreeVal = userDegree.getConvertedInput();
- Double kelvinDegree;
-
- if(getLocale().equals(Locale.US)){
- kelvinDegree = userDegreeVal + 459.67;
- BigDecimal bdKelvin = new BigDecimal(kelvinDegree);
- BigDecimal fraction = new BigDecimal(5).divide(new BigDecimal(9));
-
- kelvinDegree = bdKelvin.multiply(fraction).doubleValue();
- }else{
- kelvinDegree = userDegreeVal + 273.15;
- }
-
- setConvertedInput(kelvinDegree);
- }
-
- @Override
- protected void onBeforeRender() {
- super.onBeforeRender();
-
- Double kelvinDegree = (Double) getDefaultModelObject();
- Double userDegreeVal = null;
-
- if(kelvinDegree == null) return;
-
- if(getLocale().equals(Locale.US)){
- BigDecimal bdKelvin = new BigDecimal(kelvinDegree);
- BigDecimal fraction = new BigDecimal(9).divide(new BigDecimal(5));
-
- kelvinDegree = bdKelvin.multiply(fraction).doubleValue();
- userDegreeVal = kelvinDegree - 459.67;
- }else{
- userDegreeVal = kelvinDegree - 273.15;
- }
-
- userDegree.setModelObject(userDegreeVal);
- }
-}
-{code}
-
-Since our component does not directly receive the user input, convertInput() must read this value from the inner text field using FormComponent's getConvertedInput() method which returns the input value already converted to the type specified for the component (Double in our case). Once we have the user input we convert it to kelvin degrees and we use the resulting value to set the converted input for our custom component (using method setConvertedInput(T convertedInput)).
-
-Method onBeforeRender() is responsible for synchronizing the model of the inner textfield with the model of our custom component. To do this we retrieve the model object of the custom component with the getDefaultModelObject() method, then we convert it to the temperature scale adopted by the user and finally we use this value to set the model object of the text field.
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/helloWorld.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/helloWorld.gdoc b/wicket-user-guide/src/docs/guide/helloWorld.gdoc
deleted file mode 100644
index 6dd56b5..0000000
--- a/wicket-user-guide/src/docs/guide/helloWorld.gdoc
+++ /dev/null
@@ -1,6 +0,0 @@
-Wicket allows us to design our web pages in terms of components and containers, just like AWT does with desktop windows.
-Both frameworks share the same component-based architecture: in AWT we have a @Windows@ instance which represents the physical windows containing GUI components (like text fields, radio buttons, drawing areas, etc...), in Wicket we have a @WebPage@ instance which represents the physical web page containing HTML components (pictures, buttons, forms, etc... ) .
-
-!uml-component.png!
-
-In both frameworks we find a base class for GUI components called @Component@. Wicket pages can be composed (and usually are) by many components, just like AWT windows are composed by Swing/AWT components. Both frameworks promote the reuse of presentation code and GUI elements building custom components. Even if Wicket already comes with a rich set of ready-to-use components, building custom components is a common practice when working with this framework. We'll learn more about custom components in the next chapters.
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_1.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_1.gdoc b/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_1.gdoc
deleted file mode 100644
index bff575e..0000000
--- a/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_1.gdoc
+++ /dev/null
@@ -1,21 +0,0 @@
-Wicket is available as a binary package on the main site "http://wicket.apache.org":http://wicket.apache.org . Inside this archive we can find the distribution jars of the framework. Each jar corresponds to a sub-module of the framework. The following table reports these modules along with a short description of their purpose and with the related dependencies:
-
-{table}
- *Module'sname* | *Description* | *Dependencies*
- wicket-core | Contains the main classes of the framework, like class @Component@ and @Application@. | wicket-request, wicket-util
- wicket-request | This module contains the classes involved into web request processing. | wicket-util
- wicket-util | Contains general-purpose utility classes for functional areas such as I/O, lang, string manipulation, security, etc... | None
- wicket-datetime | Contains special purpose components designed to work with date and time. | wicket-core
- wicket-bean-validation | Provides support for JSR 303 standard validation. | wicket-core
- wicket-devutils | Contains utility classes and components to help developers with tasks such as debugging, class inspection and so on. | wicket-core, wicket-extensions
-wicket-extensions | Contains a vast set of built-in components to build a rich UI for our web application (Ajax support is part of this module). | wicket-core
-wicket-auth-roles | Provides support for role-based authorization. | wicket-core
-wicket-ioc | This module provides common classes to support Inversion Of Control. It's used by both Spring and Guice integration module. | wicket-core
-wicket-guice | This module provides integration with the dependency injection framework developed by Google. | wicket-core, wicket-ioc
-wicket-spring | This module provides integration with Spring framework. | wicket-core, wicket-ioc
-wicket-velocity | This module provides panels and utility class to integrate Wicket with Velocity template engine. | wicket-core
-wicket-jmx| This module provides panels and utility class to integrate Wicket with Java Management Extensions. | wicket-core
-wicket-objectsizeof-agent | Provides integration with Java agent libraries and instrumentation tools. | wicket-core
-{table}
-
-Please note that the core module depends on the utility and request modules, hence it cannot be used without them.
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_2.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_2.gdoc b/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_2.gdoc
deleted file mode 100644
index 5f83802..0000000
--- a/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_2.gdoc
+++ /dev/null
@@ -1,97 +0,0 @@
-In this chapter we will see a classic Hello World! example implemented using a Wicket page with a built-in component called @Label@ (the code is from project the HelloWorldExample). Since this is the first example of the guide, before looking at Java code we will go through the common artifacts needed to build a Wicket application from scratch.
-
-{note}
-All the example projects presented in this document have been generated using Maven and the utility page at "http://wicket.apache.org/start/quickstart.html":http://wicket.apache.org/start/quickstart.html . *Appendix A* contains the instructions needed to use these projects and build a quickstart application using Apache Maven. All the artifacts used in the next example (files web.xml, HomePage.class and HomePage.html) are automatically generated by Maven.
-{note}
-
-h3. Wicket application structure
-
-A Wicket application is a standard Java EE web application, hence it is deployed through a web.xml file placed inside folder WEB-INF:
-
-!webinf.png!
-
-_Illustration : The standard directory structure of a Wicket application_
-
-The content of web.xml declares a servlet filter (class @org.apache.wicket.Protocol.http.WicketFilter@) which dispatches web requests to our Wicket application:
-
-{code:xml}
-<?xml version="1.0" encoding="UTF-8"?>
-<web-app>
- <display-name>Wicket Test</display-name>
- <filter>
- <filter-name>TestApplication</filter-name>
- <filter-class>org.apache.wicket.protocol.http.WicketFilter</filter-class>
- <init-param>
- <param-name>applicationClassName</param-name>
- <param-value>org.wicketTutorial.WicketApplication</param-value>
- </init-param>
- </filter>
- <filter-mapping>
- <filter-name>TestApplication</filter-name>
- <url-pattern>/*</url-pattern>
- </filter-mapping>
-</web-app>
-{code}
-
-Since this is a standard servlet filter we must map it to a specific set of URLs through the @<filter-mapping>@ tag). In the xml above we have mapped every URL to our Wicket filter.
-
-If we are using Servlet 3 or a later version, we can of course use a class in place of web.xml to configure our application. The following example uses annotation @WebFilter.
-
-{code}
-@WebFilter(value = "/*", initParams = { @WebInitParam(name = "applicationClassName", value = "com.mycompany.WicketApplication"),
- @WebInitParam(name="filterMappingUrlPattern", value="/*") })
-public class ProjectFilter extends WicketFilter {
-
-}
-{code}
-
-
-
-{note}
-Wicket can be started in two modes named respectively DEVELOPMENT and DEPLOYMENT. The first mode activates some extra features which help application development, like resources monitoring and reloading, full stack trace rendering of exceptions, an AJAX debugger window, etc... The DEPLOYMENT mode turns off all these features optimizing performances and resource consumption. In our example projects we will use the default mode which is DEVELOPMENT. [Chapter 24.1|guide:maven_1] contains the chapter \u201cSwitching Wicket to DEPLOYMENT mode\u201c where we can find further details about these two modes as well as the possible ways we have to set the desired one. In any case, DO NOT deploy your applications in a production environment without switching to DEPLOYMENT mode!
-{note}
-
-h3. The application class
-
-If we look back at web.xml we can see that we have provided the Wicket filter with a parameter called @applicationClassName@. This value must be the fully qualified class name of a subclass of @org.apache.wicket.Application@. This subclass represents our web application built upon Wicket and it's responsible for configuring it when the server is starting up. Most of the times our custom application class won't inherit directly from class @Application@, but rather from class @org.apache.wicket.protocol.http.WebApplication@ which provides a closer integration with servlet infrastructure.
-Class @Application@ comes with a set of configuration methods that we can override to customize our application's settings. One of these methods is @getHomePage()@ that must be overridden as it is declared abstract:
-
-{code}
-public abstract Class<? extends Page> getHomePage()
-{code}
-
-As you may guess from its name, this method specifies which page to use as homepage for our application.
-Another important method is @init()@:
-
-{code}
-protected void init()
-{code}
-
-This method is called when our application is loaded by the web server (Tomcat, Jetty, etc...) and is the ideal place to put our configuration code. The @Application@ class exposes its settings grouping them into interfaces (you can find them in package @org.apache.wicket.settings@). We can access these interfaces through getter methods that will be gradually introduced in the next chapters when we will cover the related settings.
-
-The current application's instance can be retrieved at any time calling static method @Application.get()@ in our code. We will give more details about this method in [chapter 9.3|guide:requestProcessing_3]. The content of the application class from project HelloWorldExample is the following:
-
-{code}
-public class WicketApplication extends WebApplication
-{
- @Override
- public Class<? extends WebPage> getHomePage()
- {
- return HomePage.class;
- }
-
- @Override
- public void init()
- {
- super.init();
- // add your configuration here
- }
-}
-{code}
-
-Since this is a very basic example of a Wicket application, we don't need to specify anything inside the @init@ method. The home page of the application is the @HomePage@ class. In the next paragraph we will see how this page is implemented and which conventions we have to follow to create a page in Wicket.
-
-{note}
-Declaring a @WicketFilter@ inside web.xml descriptor is not the only way we have to kickstart our application.
-If we prefer to use a servlet instead of a filter, we can use class @org.apache.wicket.protocol.http.WicketServlet@. See the JavaDoc for further details.
-{note}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_3.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_3.gdoc b/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_3.gdoc
deleted file mode 100644
index e338122..0000000
--- a/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_3.gdoc
+++ /dev/null
@@ -1,61 +0,0 @@
-
-
-To complete our first Wicket application we must explore the home page class that is returned by the @Application@'s method @getHomePage()@ seen above.
-In Wicket a web page is a subclass of @org.apache.wicket.WebPage@. This subclass must have a corresponding HTML file which will be used by the framework as template to generate its HTML markup. This file is a regular plain HTML file (its extension must be html).
-
-By default this HTML file must have the same name of the related page class and must be in the same package:
-
-!samepackage.png!
-
-_Illustration :Page class and its related HTML file_
-
-If you don't like to put class and html side by side (let's say you want all your HTML files in a separated folder) you can use Wicket settings to specify where HTML files can be found. We will cover this topic later in [chapter 16.9|guide:resources_9].
-
-The Java code for the @HomePage@ class is the following:
-
-{code}
-package org.wicketTutorial;
-
-import org.apache.wicket.request.mapper.parameter.PageParameters;
-import org.apache.wicket.markup.html.basic.Label;
-import org.apache.wicket.markup.html.WebPage;
-
-public class HomePage extends WebPage {
- public HomePage() {
- add(new Label("helloMessage", "Hello WicketWorld!"));
- }
-}
-{code}
-
-Apart from subclassing @WebPage@, @HomePage@ defines a constructor that adds a @Label@ component to itself.
-Method @add(Component component)@ is inherited from ancestor class @org.apache.wicket.MarkupContainer@ and is used to add children components to a web page. We'll see more about @MarkupContainer@ later in [chapter 5.2|guide:layout_2].
-Class @org.apache.wicket.markup.html.basic.Label@ is the simplest component shipped with Wicket. It just inserts a string (the second argument of its constructor) inside the corresponding HTML tag.
-Just like any other Wicket component, @Label@ needs a textual id (@'helloMessage'@ in our example) to be instantiated. At runtime Wicket will use this value to find the HTML tag we want to bind to the component. This tag must have a special attribute called @wicket:id@ and its value must be identical to the component id (comparison is case-sensitive!).
-
-Here is the HTML markup for @HomePage@ (file HomePage.html):
-
-{code:html}
-<!DOCTYPE html>
-<html>
- <head>
- <meta charset="utf-8" />
- <title>Apache Wicket HelloWorld</title>
- </head>
- <body>
-
- <div wicket:id="helloMessage">
- [Label's message goes here]
- </div>
- </body>
-</html>
-{code}
-
-We can see that the @wicket:id@ attribute is set according to the value of the component id. If we run this example we will see the text @Hello WicketWorld!@ Inside a @<div>@ tag.
-
-{note}
-@Label@ replaces the original content of its tag (in our example @[Label's message goes here]@) with the string passed as value (@Hello WicketWorld!@ in our example).
-{note}
-
-{warning}
-If we specify a @wicket:id@ attribute for a tag without adding the corresponding component in our Java code, Wicket will throw a @ComponentNotFound@ Exception. On the contrary if we add a component in our Java code without specifying a corresponding @wicket:id@ attribute in our markup, Wicket will throw a @WicketRuntimeException@.
-{warning}
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_4.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_4.gdoc b/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_4.gdoc
deleted file mode 100644
index 1eea3a1..0000000
--- a/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_4.gdoc
+++ /dev/null
@@ -1,52 +0,0 @@
-The basic form of interaction offered by web applications is to navigate through pages using links. In HTML a link is basically a pointer to another resource that most of the time is another page. Wicket implements links with component @org.apache.wicket.markup.html.link.Link@, but due to the component-oriented nature of the framework, this component is quite different from classic HTML links.
-Following the analogy with GUI frameworks, we can consider Wicket link as a \u201cclick\u201d event handler: its purpose is to perform some actions (on server side!) when the user clicks on it.
-
-That said, you shouldn't be surprised to find an abstract method called @onClick()@ inside the @Link@ class. In the following example we have a page with a @Link@ containing an empty implementation of @onClick@:
-
-{code}
-public class HomePage extends WebPage {
- public HomePage(){
- add(new Link("id"){
- @Override
- public void onClick() {
- //link code goes here
- }
- });
- }
-}
-{code}
-
-By default after @onClick@ has been executed, Wicket will send back to the current page to the client web browser. If we want to navigate to another page we must use method @setResponsePage@ of class @Component@:
-
-{code}
-public class HomePage extends WebPage {
- public HomePage(){
- add(new Link("id"){
- @Override
- public void onClick() {
- //we redirect browser to another page.
- setResponsePage(AnotherPage.class);
- }
- });
- }
-}
-{code}
-
-In the example above we used a version of @setResponsePage@ which takes as input the class of the target page. In this way a new instance of @AnotherPage@ will be created each time we click on the link. The other version of @setResponsePage@ takes in input a page instance instead of a page class:
-
-{code}
-@Override
-public void onClick() {
- //we redirect browser to another page.
- AnotherPage anotherPage = new AnotherPage();
- setResponsePage(anotherPage);
-}
-{code}
-
-The difference between using the first version of @setResponsePage@ rather than the second one will be illustrated in [chapter 8|guide:versioningCaching], when we will introduce the topic of stateful and stateless pages. For now, we can consider them as equivalent.
-
-Wicket comes with a rich set of link components suited for every need (links to static URL, Ajax-enhanced links, links to a file to download, links to external pages and so on). We will see them in [chapter 10|guide:urls].
-
-{note}
-We can specify the content of a link (i.e. the text of the picture inside it) with its method @setBody@. This method takes in input a generic Wicket model, which will be the topic of [chapter 11|guide:modelsforms].
-{note}
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_5.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_5.gdoc b/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_5.gdoc
deleted file mode 100644
index b9d541b..0000000
--- a/wicket-user-guide/src/docs/guide/helloWorld/helloWorld_5.gdoc
+++ /dev/null
@@ -1,3 +0,0 @@
-In this chapter we have seen the basic elements that compose a Wicket application. We have started preparing the configuration artifacts needed for our applications. As promised in [chapter 2.4|guide:helloWorld_4], we needed to put in place just a minimal amount of XML with an application class and a home page.
-Then we have continued our \u201cfirst contact\u201d with Wicket learning how to build a simple page with a label component as child. This example page has shown us how Wicket maps components to HTML tags and how it uses both of them to generate the final HTML markup.
-In the last paragraph we had a first taste of Wicket links and we have seen how they can be considered as a \u201cclick\u201d event listener and how they can be used to navigate from a page to another.
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/howToSource.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/howToSource.gdoc b/wicket-user-guide/src/docs/guide/howToSource.gdoc
deleted file mode 100644
index 99004aa..0000000
--- a/wicket-user-guide/src/docs/guide/howToSource.gdoc
+++ /dev/null
@@ -1,15 +0,0 @@
-Most of the code you will find in this document is available as a "Git repository":https://github.com/bitstorm/Wicket-tutorial-examples and is licensed under the ASF 2.0. Examples are hosted live at {externalink:wicket.tutorial.examples.url}. To get a local copy of the repository you can run the clone command from shell:
-
-{code}
-git clone https://github.com/bitstorm/Wicket-tutorial-examples.git
-{code}
-
-If you aren't used to Git, you can simply download the whole source as a zip archive:
-
-!gitRepo.png!
-
-The repository contains a multi-module Maven project. Every subproject is contained in the relative folder of the repository:
-
-!gitMavenPrj.png!
-
-When the example code is used in the document, you will find the name of the subproject it belongs to. If you don't have any experience with Maven, you can read Appendix A where you can learn the basic commands needed to work with the example projects and to import them into your favourite IDE (NetBeans, IDEA or Eclipse).
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/i18n.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/i18n.gdoc b/wicket-user-guide/src/docs/guide/i18n.gdoc
deleted file mode 100644
index c8dcaba..0000000
--- a/wicket-user-guide/src/docs/guide/i18n.gdoc
+++ /dev/null
@@ -1 +0,0 @@
-In [chapter 12.2|guide:forms2_2] we have seen how the topic of localization is involved in the generation of feedback messages and we had a first contact with resource bundles. In this chapter we will continue to explore the localization support provided by Wicket and we will learn how to build pages and components ready to be localized in different languages.
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/i18n/i18n_1.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/i18n/i18n_1.gdoc b/wicket-user-guide/src/docs/guide/i18n/i18n_1.gdoc
deleted file mode 100644
index 46c7eb8..0000000
--- a/wicket-user-guide/src/docs/guide/i18n/i18n_1.gdoc
+++ /dev/null
@@ -1,27 +0,0 @@
-
-
-As we have seen in [paragraph 12.2|guide:forms2_2], the infrastructure of feedback messages is built on top of Java internationalization (i18n) support, so it should not be surprising that the same infrastructure is used also for localization purpose. However, while so far we have used only the <ApplicationClassName>.properties file to store our custom messages, in this chapter we will see that also pages, components, validators and even Java packages can have their own resource bundles. This allows us to split bundles into multiple files keeping them close to where they are used. But before diving into the details of internationalization with Wicket, it's worthwhile to quickly review how i18n works under Java, see what classes are involved and how they are integrated into Wicket.
-
-{note}
-Providing a full description of Java support for i18n is clearly out of the scope of this document. If you need more informations about this topic you can find them in the JavaDocs and in the official "i18n tutorial":http://docs.oracle.com/javase/tutorial/i18n/index.html .
-{note}
-
-h3. Class Locale and ResourceBundle
-
-Class java.util.Locale represents a specific country or language of the world and is used in Java to retrieve other locale-dependent informations like numeric and date formats, the currency in use in a country and so on. Such kind of informations are accessed through special entities called resource bundles which are implemented by class @java.util.ResourceBundle@. Every resource bundle is identified by a full name which is built using four parameters: a base name (which is required), a language code, a country code and a variant (which are all optional). These three optional parameters are provided by an instance of Locale with its three corresponding getter methods: getLanguage(), getCountry() and getVariant(). Parameter language code is a lowercase ISO 639 2-letter code (like zh for Chinese, de for German and so on) while country code is an uppercase ISO 3166 2-letter code (like CN for China, DE for Germany and so on). The final full name will have the following structure (NOTE:
tokens inside squared brackets are optional):
-
-{code}
-<base name>[_<language code>[_<COUNTRY_CODE>[_<variant code>]]]
-{code}
-
-For example a bundle with MyBundle as base name and localized for Mandarin Chinese (language code zh, country code CH, variant cmn) will have MyBundle_zh_CH_cmn as full name. A base name can be a fully qualified class name, meaning that it can include a package name before the actual base name. The specified package will be the container of the given bundle. For example if we use org.foo.MyBundle as base name, the bundle named MyBundle will be searched inside package org.foo. The actual base name (MyBundle in our example) will be used to build the full name of the bundle following the same rules seen above.
-@ResourceBundle@ is an abstract factory class, hence it exposes a number of factory methods named getBundle to load a concrete bundle. Without going into too much details we can say that a bundle corresponds to a file in the classpath. To find a file for a given bundle, getBundle needs first to generate an ordered list of candidate bundle names. These names are the set of all possible full names for a given bundle. For example if we have org.foo.MyBundle as base name and the current locale is the one seen before for Mandarin Chinese, the candidate names will be:
-
-# org.foo.MyBundle_zh_CH_cmn
-# org.foo.MyBundle_zh_CH
-# org.foo.MyBundle_zh
-# org.foo.MyBundle
-
-The list of these candidate names is generated starting from the most specific one and subtracting an optional parameter at each step. The last name of the list corresponds to the default resource bundle which is the most general name and is equal to the base name. Once that getBundle has generated the list of candidate names, it will iterate over them to find the first one for which is possible to load a class or a properties file. The class must be a subclass of @ResourceBundle@ having as class name the full name used in the current iteration. If such a class is not found, getBundle will try to locate a properties file having a file name equals to the current full name (Java will automatically append extension .properties to the full name). For example given the resource bundle of the previous example, Java will search first for class org.foo.MyBundle_zh_CH_cmn and then for file MyBundle_zh_CH_cmn.properties inside package org.foo. If no file is found for any of the candidate name
s, a MissingResourceException will be thrown. Bundles contains local-dependent string resources identified by a key that is unique in the given bundle. So once we have obtained a valid bundle we can access these objects with method getString (String key).
-
-As we have seen before working with feedback messages, in Wicket most of the times we will work with properties files rather than with bundle classes. In [paragraph 12.2|guide:forms2_2] we used a properties file having as base name the class name of the application class and without any information about the locale. This file is the default resource bundle for a Wicket application. In [paragraph 15.3|guide:i18n_3] we will explore the algorithm used in Wicket to locate the available bundles for a given component. Once we have learnt how to leverage this algorithm, we will be able to split our bundles into more files organized in a logical hierarchy.
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/i18n/i18n_2.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/i18n/i18n_2.gdoc b/wicket-user-guide/src/docs/guide/i18n/i18n_2.gdoc
deleted file mode 100644
index f16f613..0000000
--- a/wicket-user-guide/src/docs/guide/i18n/i18n_2.gdoc
+++ /dev/null
@@ -1,148 +0,0 @@
-
-
-A component can get the current locale in use calling its method getLocale(). By default this method will be recursively called on component's parent containers until one of them returns a valid locale. If no one of them returns a locale, this method will get the one associated with the current user session. This locale is automatically generated by Wicket in accordance with the language settings of the browser.
-
-Developers can change the locale of the current session with Session's method setLocale (Locale locale):
-
-{code}
-Session.get().setLocale(locale)
-{code}
-
-h3. Style and variation parameters for bundles
-
-In addition to locale's informations, Wicket supports two further parameters to identify a resource bundle: style and variation. Parameter style is a string value and is defined at session-level. To set/get the style for the current session we can use the corresponding setter and getter of class Session:
-
-{code}
-Session.get().setStyle("myStyle");
-Session.get().getStyle();
-{code}
-
-If set, style's value contributes to the final full name of the bundle and it is placed between the base name and the locale's informations:
-
-{code}
-<base name>[_style][_<language code>[_<COUNTRY_CODE>[_<variant code>]]]
-{code}
-
-Wicket gives the priority to candidate names containing the style information (if available). The other parameter we can use for localization is variation. Just like style also variation is a string value, but it is defined at component-level. The value of variation is returned by Component's method getVariation(). By default this method returns the variation of the parent component or a null value if a component hasn't a parent (i.e. it's a page). If we want to customize this parameter we must overwrite method getVariation and make it return the desired value.
-
-Variation's value contributes to the final full name of the bundle and is placed before style parameter:
-
-{code}
-<base name>[_variation][_style][_<language code>[_<COUNTRY_CODE>[_<variant code>]]]
-{code}
-
-
-h3. Using UTF-8 for resource bundles
-
-Java uses the standard character set "ISO 8859-11":http://en.wikipedia.org/wiki/ISO/IEC_8859-1 to encode text files like properties files. Unfortunately ISO 8859-1 does not support most of the extra-European languages like Chinese or Japanese. The only way to use properties files with such languages is to use escaped "Unicode":http://en.wikipedia.org/wiki/List_of_Unicode_characters characters, but this leads to not human-readable files. For example if we wanted to write the word 'website' in simplified Chinese (the ideograms are \u7f51\u7ad9) we should write the Unicode characters @\u7F51\u7AD9@.
-For this reason ISO 8859-11 is being replaced with another Unicode-compliant character encoding called UTF-8. Text files created with this encoding can contain Unicode symbols in plain format.
-Wicket provides a useful convention to use properties file encoded with UTF-8. We just have to add prefix @.utf8.@ to file extension (i.e. @.utf8.properties@).
-
-{note}
-If you want to use UTF-8 with your text files, make sure that your editor/IDE is actually using this character encoding. Some OS like Windows use a different encoding by default.
-{note}
-
-h3. Using XML files as resource bundles
-
-Starting from version 1.5, Java introduced the support for XML files as resource bundles. XML files are generally encoded with character sets UTF-8 or UTF-16 which support every symbol of the Unicode standard. In order to be a valid resource bundle the XML file must conform to the DTD available at "http://java.sun.com/dtd/properties.dtd":http://java.sun.com/dtd/properties.dtd .
-
-Here is an example of XML resource bundle taken from project LocalizedGreetings (file WicketApplication_zh.properties.xml) containing the translation in simplified Chinese of the greeting message \u201cWelcome to the website!\u201d:
-
-{code:xml}
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
-<properties>
- <entry key="greetingMessage">\u6b22\u8fce\u5149\u4e34\u672c\u7f51\u7ad9\uff01</entry>
-</properties>
-{code}
-
-To use XML bundles in Wicket we don't need to put in place any additional configuration. The only rule we have to respect with these files is to use properties.xml as extension while their base name follows the same rules seen so far for bundle names.
-
-h3. Reading bundles from code
-
-Class Component makes reading bundles very easy with method getString(String key). This method searches for a resource with the given key looking into the resource bundles visited by the lookup algorithm illustrated in [paragraph 15.3|guide:i18n_3]. For example if we have a greeting message with key greetingMessage in our application's resource bundle, we can read it from our component code with this instruction:
-
-{code}
-getString("greetingMessage");
-{code}
-
-h3. Localization of bundles in Wicket
-
-In [paragraph 12.2|guide:forms2_2] we have used as resource bundle the properties file placed next to our application class. This file is the default resource bundle for the entire application and it is used by the lookup algorithm if it doesn't find any better match for a given component and locale. If we want to provide localized versions of this file we must simply follow the rules of Java i18n and put our translated resources into another properties file with a name corresponding to the desired locale. For example project LocalizedGreetings comes with the default application's properties file ( WicketApplication.properties) containing a greeting message:
-
-{code}
-greetingMessage=Welcome to the site!
-{code}
-
-Along with this file we can also find a bundle for German (WicketApplication_de.properties) and another one in XML format for simplified Chinese (WicketApplication_zh.properties.xml). The example project consists of a single page (HomePage.java) displaying the greeting message. The current locale can be changed with a drop-down list and the possible options are English (the default one), German and simplified Chinese:
-
-!locale-german.png!
-
-The label displaying the greeting message has a custom read-only model which returns the message with method getString. The initialization code for this label is this:
-
-{code}
-AbstractReadOnlyModel<String> model = new AbstractReadOnlyModel<String>() {
- @Override
- public String getObject() {
- return getString("greetingMessage");
- }
-};
-
-add(new Label("greetingMessage", model));
-{code}
-
-Class @org.apache.wicket.model.AbstractReadOnlyModel@ is a convenience class for implementing read-only models. In this project we have implemented a custom read-only model for illustrative purposes only because Wicket already provides built-in models for the same task. We will see them in paragraph [paragraph 15.5|guide:i18n_5].
-
-The rest of the code of the home page builds the stateless form and the drop-down menu used to change the locale.
-
-{code}
-List<Locale> locales = Arrays.asList(Locale.ENGLISH, Locale.CHINESE, Locale.GERMAN);
-final DropDownChoice<Locale> changeLocale =
- new DropDownChoice<Locale>("changeLocale", new Model<Locale>(), locales);
-
-StatelessForm form = new StatelessForm("form"){
- @Override
- protected void onSubmit() {
- Session.get().setLocale(changeLocale.getModelObject());
- }
-};
-
-setStatelessHint(true);
-add(form.add(changeLocale))
-{code}
-
-
-h3. Localization of markup files
-
-Although resource bundles exist to extract local-dependent elements from our code and from UI components, in Wicket we can decide to provide different markup files for different locale settings. Just like standard markup files, by default localized markup files must be placed next to component's class and their file name must contain the locale's informations. In the following picture, CustomPanel comes with a standard (or default) markup file and with another one localized for German:
-
-!comp-with-markup-german.png!
-
-When the current locale corresponds to German country (language code de), markup file CustomPanel_de.html will be used in place of the default one.
-
-h3. Reading bundles with tag <wicket:message>
-
-String resources can be also retrieved directly from markup code using tag <wicket:message>. The key of the desired resource is specified with attribute key:
-
-{code:xml}
-<wicket:message key="greetingMessage">message goes here</wicket:message>
-{code}
-
-By default the resource value is not escaped for HTML entities. To do that use the @escape@ attribute:
-
-{code:xml}
-<wicket:message key="greetingMessage" escape="true">message goes here</wicket:message>
-{code}
-
-
-@wicket:message@ can be adopted also to localize the attributes of a tag. The name of the attribute and the resource key are expressed as a colon-separated value. In the following markup the content of attribute @value@ will be replaced with the localized resource having 'key4value' as key:
-
-{code:html}
-<input type="submit" value="Preview value" wicket:message="value:key4value"/>
-{code}
-
-If we want to specify multiple attributes at once, we can separate them with a comma:
-
-{code:html}
-<input type="submit" value="Preview value" wicket:message="value:key4value, title:key4title"/>
-{code}
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/i18n/i18n_3.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/i18n/i18n_3.gdoc b/wicket-user-guide/src/docs/guide/i18n/i18n_3.gdoc
deleted file mode 100644
index 04a1453..0000000
--- a/wicket-user-guide/src/docs/guide/i18n/i18n_3.gdoc
+++ /dev/null
@@ -1,101 +0,0 @@
-
-
-As we hinted at the beginning of this chapter, by default Wicket provides a very flexible algorithm to locate the resource bundles available for a given component. In this paragraph we will learn how this default lookup algorithm works and which options it offers to manage our bundle files.
-
-h3. Localizing pages and panels
-
-Similarly to application class, also component classes can have their own bundle files having as base name the class name of the related component and placed in the same package. So for example if class CustomPanel is a custom panel we created, we can provide it with a default bundle file called CustomPanel.properties containing the textual resources used by this panel. This rule applies to page classes as well:
-
-!page-and-panel-bundle.png!
-
-One fundamental thing to keep in mind when we work with these kinds of bundles is that the lookup algorithm gives priority to the bundles of the containers of the component that is requesting a localized resource. The more a container is higher in the hierarchy, the bigger is its priority over the other components. This mechanism was made to allow containers to overwrite resources used by children components. As a consequence the values inside the resource bundle of a page will have the priority over the other values with the same key defined in the bundles of children components.
-
-To better grasp this concept let's consider the component hierarchy depicted in the following picture:
-
-!custom-panel-bundle.png!
-
-If CustomPanel tries to retrieve the string resource having 'message' as key, it will get the value 'Wellcome!' and not the one defined inside its own bundle file.
-
-The default message-lookup algorithm is not limited to component hierarchy but it also includes the class hierarchy of every component visited in the search strategy described so far. This makes bundle files inheritable, just like markup files. When the hierarchy of a container component is explored, any ancestor has the priority over children components. Consider for example the hierarchy in the following picture:
-
-!custom-panel-bundle2.png!
-
-Similarly to the previous example, the bundle owned by CustomPanel is overwritten by the bundle of page class BasePage (which has been inherited by CustomPage).
-
-h3. Component-specific resources
-
-In order to make a resource specific for a given child component, we can prefix the message key with the id of the desired component. Consider for example the following code and bundle of a generic page:
-
-Page code:
-
-{code}
-add(new Label("label",new ResourceModel("labelValue")));
-add(new Label("anotherLabel",new ResourceModel("labelValue")));
-{code}
-
-Page bundle:
-
-{code}
-labelValue=Default value
-anotherLabel.labelValue=Value for anotherLabel
-{code}
-
-Label with id anotherLabel will display the value 'Value for anotherLabel' while label label will display 'Default value'. In a similar fashion, parent containers can specify a resource for a nested child component prepending also its relative path (the path is dot-separated):
-
-Page code:
-
-{code}
-Form form = new Form("form");
-form.add(new Label("anotherLabel",new ResourceModel("labelValue")));
-add(form);
-{code}
-
-Page bundle:
-
-{code}
-labelValue=Default value
-anotherLabel.labelValue=Value for anotherLabel
-form.anotherLabel.labelValue=Value for anotherLabel inside form
-{code}
-
-With the code and the bundle above, the label inside the form will display the value 'Value for anotherLabel inside form'.
-
-h3. Package bundles
-
-If no one of the previous steps can find a resource for the given key, the algorithm will look for package bundles. These bundles have @wicket-package@ as base name and they can be placed in one of the package of our application:
-
-!package-bundles.png!
-
-Packages are traversed starting from the one containing the component requesting for a resource and going up to the root package.
-
-h3. Bundles for feedback messages
-
-The algorithm described so far applies to feedback messages as well. In case of validation errors, the component that has caused the error will be considered as the component which the string resource is relative to. Furthermore, just like application class and components, validators can have their own bundles placed next to their class and having as base name their class name. This allows us to distribute validators along with the messages they use to report errors:
-
-!validator-with-bundle.png!
-
-Validator's resource bundles have the lowest priority in the lookup algorithm. They can be overwritten by resource bundles of components, packages and application class.
-
-h3. Extending the default lookup algorithm
-
-Wicket implements the default lookup algorithm using the strategy pattern. The concrete strategies are abstracted with the interface @org.apache.wicket.resource.loader.IStringResourceLoader@. By default Wicket uses the following implementations of @IStringResourceLoader@ (sorted by execution order):
-
-# *ComponentStringResourceLoader:* implements most of the default algorithm. It searches for a given resource across bundles from the container hierarchy, from class hierarchy and from the given component.
-# *PackageStringResourceLoader:* searches into package bundles.
-# *ClassStringResourceLoader:* searches into bundles of a given class. By default the target class is the application class.
-# *ValidatorStringResourceLoader:* searches for resources into validator's bundles. A list of validators is provided by the form component that failed validation.
-# *InitializerStringResourceLoader:* this resource allows internationalization to interact with the initialization mechanism of the framework that will be illustrated in [paragraph 18.3|guide:advanced_3].
-# *NestedStringResourceLoader:* allows to replace nested Strings and can be chained up with other resource loader
-
-Developer can customize lookup algorithm removing default resource loaders or adding custom implementations to the list of the resource loaders in use. This task can be accomplished using method getStringResourceLoaders of setting class @org.apache.wicket.settings.ResourceSettings@:
-
-{code}
-@Override
-public void init()
-{
- super.init();
- //retrieve ResourceSettings and then the list of resource loaders
- List<IStringResourceLoader> resourceLoaders = getResourceSettings().
- getStringResourceLoaders();
- //customize the list...
-{code}
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/i18n/i18n_4.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/i18n/i18n_4.gdoc b/wicket-user-guide/src/docs/guide/i18n/i18n_4.gdoc
deleted file mode 100644
index 1dd962f..0000000
--- a/wicket-user-guide/src/docs/guide/i18n/i18n_4.gdoc
+++ /dev/null
@@ -1,67 +0,0 @@
-
-
-Components that inherit from @AbstractChoice@ (such as @DropDownChoice@, @CheckBoxMultipleChoice@ and @RadioChoice@) must override method @localizeDisplayValues@ and make it return true to localize the values displayed for their choices. By default this method return false so values are displayed as they are. Once localization is activated we can use display values as key for our localized string resources. In project LocalizedChoicesExample we have a drop-down list that displays four colors (green, red, blue, and yellow) which are localized in three languages (English, German and Italian). The current locale can be changed with another drop-down menu (in a similar fashion to project @LocalizedGreetings@). The code of the home page and the relative bundles are the following:
-
-Java code:
-
-{code}
-public HomePage(final PageParameters parameters) {
- super(parameters);
-
- List<Locale> locales = Arrays.asList(Locale.ENGLISH, Locale.ITALIAN, Locale.GERMAN);
- List<String> colors = Arrays.asList("green", "red", "blue", "yellow");
-
- final DropDownChoice<Locale> changeLocale = new DropDownChoice<Locale>("changeLocale",
- new Model<Locale>(), locales);
-
- StatelessForm form = new StatelessForm("form"){
- @Override
- protected void onSubmit() {
- Session.get().setLocale(changeLocale.getModelObject());
- }
- };
-
- DropDownChoice<String> selectColor = new DropDownChoice<String>("selectColor", new
- Model<String>(), colors){
- @Override
- protected boolean localizeDisplayValues() {
- return true;
- }
- };
-
- form.add(selectColor);
- add(form.add(changeLocale));
- }
-{code}
-
-Default bundle (English):
-
-{code}
-selectColor.null=Select a color
-green=Green
-red=Red
-blue=Blue
-yellow=Yellow
-{code}
-
-German bundle:
-
-{code}
-selectColor.null=W�hlen Sie eine Farbe
-green=Gr�n
-red=Rot
-blue=Blau
-yellow=Gelb
-{code}
-
-Italian bundle:
-
-{code}
-selectColor.null=Scegli un colore
-green=Verde
-red=Rosso
-blue=Blu
-yellow=Giallo
-{code}
-
-Along with the localized versions of colors names, in the bundles above we can also find a custom value for the placeholder text (\u201cSelect a color \u201d) used for null value. The resource key for this resource is 'null' or '<component id>.null' if we want to make it component-specific.
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/i18n/i18n_5.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/i18n/i18n_5.gdoc b/wicket-user-guide/src/docs/guide/i18n/i18n_5.gdoc
deleted file mode 100644
index 4db429d..0000000
--- a/wicket-user-guide/src/docs/guide/i18n/i18n_5.gdoc
+++ /dev/null
@@ -1,102 +0,0 @@
-
-
-Internationalization is another good chance to taste the power of models. Wicket provides two built-in models to better integrate our components with string resources: they are ResourceModel and StringResourceModel.
-
-h3. ResourceModel
-
-Model @org.apache.wicket.model.ResourceModel@ acts just like the read-only model we have implemented in [paragraph 15.3|guide:i18n_3]. It simply retrieves a string resource corresponding to a given key:
-
-{code}
-//build a ResourceModel for key 'greetingMessage'
-new ResourceModel("greetingMessage");
-{code}
-
-We can also specify a default value to use if the requested resource is not found:
-
-{code}
-//build a ResourceModel with a default value
-new ResourceModel("notExistingResource", "Resource not found.");
-{code}
-
-h3. StringResourceModel
-
-Model @org.apache.wicket.model.StringResourceModel@ allows to work with complex and dynamic string resources containing parameters and property expressions. The basic constructor of this model takes in input a resource key and another model. This further model can be used by both the key and the related resource to specify dynamic values with property expressions. For example let's say that we are working on an e-commerce site which has a page where users can see an overview of their orders. To handle the state of user's orders we will use the following bean and enum (the code is from project StringResourceModelExample):
-
-Bean:
-
-{code}
-public class Order implements Serializable {
-
- private Date orderDate;
- private ORDER_STATUS status;
-
- public Order(Date orderDate, ORDER_STATUS status) {
- super();
- this.orderDate = orderDate;
- this.status = status;
- }
- //Getters and setters for private fields
-}
-{code}
-
-Enum:
-
-{code}
-public enum ORDER_STATUS {
-
- PAYMENT_ACCEPTED(0),
- IN_PROGRESS(1),
- SHIPPING(2),
- DELIVERED(3);
-
- private int code;
- //Getters and setters for private fields
-}
-{code}
-
-Now what we want to do in this page is to print a simple label which displays the status of an order and the date on which the order has been submitted. All the informations about the order will be passed to a StringResourceModel with a model containing the bean Order. The bundle in use contains the following key/value pairs:
-
-{code}
-orderStatus.0=Your payment submitted on ${orderDate} has been accepted.
-orderStatus.1=Your order submitted on ${orderDate} is in progress.
-orderStatus.2=Your order submitted on ${orderDate} has been shipped.
-orderStatus.3=Your order submitted on ${orderDate} has been delivered.
-{code}
-
-The values above contain a property expression (${orderDate}) that will be evaluated on the data object of the model. The same technique can be applied to the resource key in order to load the right resource according to the state of the order:
-
-{code}
-Order order = new Order(new Date(), ORDER_STATUS.IN_PROGRESS);
-add(new Label("orderStatus", new StringResourceModel("orderStatus.${status.code}", Model.of(order))));
-{code}
-
-As we can see in the code above also the key contains a property expression (${status.code}) which makes its value dynamic. In this way the state of an object (an Order in our example) can determinate which resource will be loaded by StringResourceModel. If we don't use properties expressions we can provide a null value as model and in this case StringResourceModel will behave exactly as a ResourceModel. StringResourceModel supports also the same parameter substitution used by standard class @java.text.MessageFormat@.
-
-Parameters can be generic objects but if we use a model as parameter, StringResourceModel will use the data object inside it as actual value (it will call getObject on the model). Parameters are passed as a vararg argument with method @setParameters(Object... parameters)@. Here is an example of usage of parameter substitution:
-
-Java code:
-
-{code}
-PropertyModel propertyModel = new PropertyModel<Order>(order, "orderDate");
-//build a string model with two parameters: a property model and an integer value
-StringResourceModel srm = new StringResourceModel("orderStatus.delay").setParameters(propertyModel, 3);
-{code}
-
-Bundle:
-
-{code}
-orderStatus.delay=Your order submitted on ${0} has been delayed by {1} days.
-{code}
-
-One further parameter we can specify when we build a StringResourceModel is the component that must be used by the lookup algorithm. Normally this parameter is not relevant, but if we need to use a particular bundle owned by a component not considered by the algorithm, we can specify this component as second parameter. If we pass all possible parameters to StringResourceModel's constructor we obtain something like this:
-
-{code}
-new StringResourceModel("myKey", myComponent, myModel);
-{code}
-
-Default value is supported as well, both as string model or as string value:
-
-{code}
-new StringResourceModel("myKey", myComponent, myModel).setDefaultValue("default");
-{code}
-
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/i18n/i18n_6.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/i18n/i18n_6.gdoc b/wicket-user-guide/src/docs/guide/i18n/i18n_6.gdoc
deleted file mode 100644
index 0c9050f..0000000
--- a/wicket-user-guide/src/docs/guide/i18n/i18n_6.gdoc
+++ /dev/null
@@ -1,3 +0,0 @@
-
-
-Internationalization is a mandatory step if we want to take our applications (and our business!) abroad. Choosing the right strategy to manage our localized resources is fundamental to avoid to make a mess of them. In this chapter we have explored the built-in support for localization provided by Wicket, and we have learnt which solutions it offers to manage resource bundles. In the final part of the chapter we have seen how to localize the options displayed by a component (such as DropDownChoice or RadioChoice) and we also introduced two new models specifically designed to localize our components without introducing in their code any detail about internationalization.
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/internals.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/internals.gdoc b/wicket-user-guide/src/docs/guide/internals.gdoc
deleted file mode 100644
index e69de29..0000000
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/internals/autocomponents.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/internals/autocomponents.gdoc b/wicket-user-guide/src/docs/guide/internals/autocomponents.gdoc
deleted file mode 100644
index ee7ac07..0000000
--- a/wicket-user-guide/src/docs/guide/internals/autocomponents.gdoc
+++ /dev/null
@@ -1,76 +0,0 @@
-h3. Markup loading and parsing
-
-Before rendering any component Wicket must retrieve its markup calling method @getMarkup()@ of class @org.apache.wicket.Component@. This markup is an instance of interface @org.apache.wicket.markup.IMarkupFragment@. Markup is lazy loaded the first time we render the relative component and is cached at application level. The internal class that actually loads the markup is @org.apache.wicket.markup.MarkupFactory@ and is part of application's markup settings:
-
-{code}
- //get current markup factory
- Application.get().getMarkupSettings().getMarkupFactory()
-{code}
-
-After the markup has been loaded by @MarkupFactory@, it's parsed with class @org.apache.wicket.markup.MarkupParser@. @MarkupFactory@ creates a new @MarkupParser@ with method @newMarkupParser(MarkupResourceStream resource)@. The effective markup parsing is performed with a chain of entities implementing interface @org.apache.wicket.markup.parser.IMarkupFilter@. The default set of @IMarkupFilters@S used by @MarkupParser@ takes care of different tasks such as HTML validation, comments removing, Wicket tags handling, etc...
-
-To customize the set of @IMarkupFilters@S used in our application we can create a subclass of @MarkupFactory@ overriding method @newMarkupParser(MarkupResourceStream resource)@:
-
-{code}
-public MyMarkupFactory
-{
-...
- public MarkupParser newMarkupParser(final MarkupResourceStream resource)
- {
- MarkupParser parser = super.newMarkupParser(resource);
- parser.add(new MyFilter());
- return parser;
- }
-}
-{code}
-
-This custom class must be registered in the markup settings during application's initialization:
-
-{code}
-@Override
-public void init()
-{
- super.init();
- getMarkupSettings().setMarkupFactory(myMarkupFactory)
-}
-{code}
-
-Usually we won't need to change the default configuration of @IMarkupFilters@S, but it's important to be aware of this internal mechanism before we talk about another advanced feature, which is building auto components resolvers.
-
-h3. Auto components resolvers
-
-Even if Wicket encourages developers to use just standard HTML in their markup code, in this guide we have seen a number of "special" tags (those starting with @wicket:@) that help us for specific tasks (e.g. @wicket:enclosure@ tag). Wicket handles most of these tags creating a corresponding special component called _auto_ component. This kind of components are resolved in two steps:
-
-# first their tag is identified by a @IMarkupFilters@ which also takes care of assigning a unique tag id.
-# then during rendering phase when an auto-component is found a new component is created for it using one of the registered @org.apache.wicket.markup.resolver.IComponentResolver@:
-
-{code}
-public interface IComponentResolver extends IClusterable
-{
- /**
- * Try to resolve a component.
- *
- * @param container
- * The container parsing its markup
- * @param markupStream
- * The current markupStream
- * @param tag
- * The current component tag while parsing the markup
- * @return component or {@code null} if not found
- */
- public Component resolve(final MarkupContainer container, final MarkupStream markupStream,
- final ComponentTag tag);
-}
-{code}
-
-Registered @IComponentResolver@s can be retrieved through Application's settings:
-
-{code}
-Application.get()
- .getPageSettings()
- .getComponentResolvers()
-{code}
-
-{note}
-An internal utility class named @org.apache.wicket.markup.resolver.ComponentResolvers@ is also available to resolve autocomponents for the current markup tag.
-{note}
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/internals/pagestoring.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/internals/pagestoring.gdoc b/wicket-user-guide/src/docs/guide/internals/pagestoring.gdoc
deleted file mode 100644
index dd26b75..0000000
--- a/wicket-user-guide/src/docs/guide/internals/pagestoring.gdoc
+++ /dev/null
@@ -1,90 +0,0 @@
-During request handling, Wicket manages page instances through interface @org.apache.wicket.request.handler.IPageProvider@. This interface creates a new page instance or loads a previously serialized page instance if we provide the corrisponding page id. @IPageProvider@ delegates page creation and retrieval to interface @org.apache.wicket.request.mapper.IPageSource@.
-When page class is provided @IPageSource@ delegates page creation to interface @org.apache.wicket.IPageFactory@, while when page id is provided it uses interface @org.apache.wicket.page.IPageManager@ to load the previously serialized page.
-
-The following workflow diagram summarizes the mechanism seen so far:
-
-!page-storage.png!
-
-h3. IPageManager
-
-@org.apache.wicket.page.IPageManager@'s task is to manage which pages have been used in a request and store their last state in the backing stores, namely @IPageStore@.
-The default implementation @org.apache.wicket.page.PageStoreManager@ collects all stateful pages which have been used in the request cycle (more than one page can be used in a single request if for example @setResponsePage()@ or @RestartResponseException@ is used).
-At the end of the request all collected page instances are being stored in the first level cache - http session. They are stored in http session attribute named @"wicket:persistentPageManagerData-APPLICATION_NAME"@ and passed to the underlying @IPageStore@.
-When the next http request comes @IPageProvider@ will ask for page with specific id and @PageStoreManager@ will look first in the http session and if no match is found then it will delegate to the IPageStore. At the end of the second request the http session based cache is being overwritten completely with the newly used page instances.
-
-To setup another @IPageManager@ implementation use @org.apache.wicket.Application.setPageManagerProvider(IPageManagerProvider)@.
-The custom @IPageManager@ implementation may or may not use @IPageStore/IDataStore@.
-
-h3. IPageStore
-
-@org.apache.wicket.pageStore.IPageStore@'s role is to mediate the storing and loading of pages done by the underlying @IDataStore@. The default implementation @org.apache.wicket.pageStore.DefaultPageStore@ pre-processes the pages before passing them to @IDataStore#storeData(String, int, byte[])@ and to post-processes them after @IDataStore#getData(String, int)@. The processing consists of transforming the page instance to @org.apache.wicket.pageStore.DefaultPageStore.SerializedPage@. This is a struct of:
-
-{code}
-{
- sessionId: String,
- pageId : int,
- data : byte[]
-}
-{code}
-
-i.e. this is the serialized page instance (data) plus additional information needed to be able to easily find it later (sessionId, pageId).
-
-When a @SerializedPage@ has to be stored @DefaultPageStore@ stores it in a application scoped cache ({sessionId, pageId} -> SerializedPage) and additionally gives it to the underlying @IDataStore#storeData(sessionId, pageId, data)@. The application scoped cache is used as second level cache. Getting a page from it is slower than the http session based cache in @PageStoreManager@ because the page has to be deserialized, but is faster than the underlying @IDataStore@ which stores the page bytes in some persistent store.
-
-The size of the application scoped cache is configurable via @org.apache.wicket.settings.StoreSettings.setInmemoryCacheSize(int)@.
-
-h3. IDataStore
-
-@org.apache.wicket.pageStore.IDataStore@ is used to persist Wicket pages (as bytes) to a persistent store like e.g. files or databases. The default implementation is @org.apache.wicket.pageStore.DiskDataStore@ which as its name says stores the pages in files. The location of the folder where the files are stored is configurable via @org.apache.wicket.settings.StoreSettings.setFileStoreFolder(File)@, by default the web container's work folder is used (ServletContext attribute 'javax.servlet.context.tempdir'). In this folder a sub-folder is created named @'applicationName-filestore'@.
-This folder contains a sub-folder for each active http session. This session folder contains a single file named 'data' which contains the bytes for the pages. The size of this 'data' file is configurable via @org.apache.wicket.settings.StoreSettings.setMaxSizePerSession(Bytes)@. When this size is exceeded the newly stored files overwrite the oldest ones.
-
-h3. AsynchronousDataStore
-
-By default Wicket wraps @DiskDataStore@ with @org.apache.wicket.pageStore.AsynchronousDataStore@. The role of @AsynchronousDataStore@ is to detach the http worker thread from waiting for the write of the page bytes to the disk.
-To disable it use: @org.apache.wicket.settings.StoreSettings.setAsynchronous(false)@. AsynchronousDataStore can delay the storage of pages' bytes for at most @org.apache.wicket.settings.StoreSettings.setAsynchronousQueueCapacity(int)@ pages. If this capacity is exceeded then the page's bytes are written synchronously to the backing @IDataStore@.
-
-h3. DebugDiskDataStore
-
-Wicket provides an extension of @DiskDataStore@ that can be used to browse the content of the 'data' files created by @DiskDataStore@. This extension can be found in wicket-devutils.jar and needs to be enabled in the @init@-method of your application via
-{code}
- DebugDiskDataStore.register(this);
-{code}
-The debug information can be seen at http://host:port/context/wicket/internal/debug/diskDataStore
-
-h3. HttpSessionDataStore
-
-In some environments like Google AppEngine it is not allowed to write to the file system and thus @DiskDataStore@ cannot be used. In this case @org.apache.wicket.pageStore.memory.HttpSessionDataStore@ can be used as replacement. This implementation of @IDataStore@ is not persistent and puts all the data in the http session.
-Wicket comes with 2 default eviction strategies to keep the size of the http session reasonable:
-
-* *org.apache.wicket.pageStore.memory.PageNumberEvictionStrategy* - specifies how many pages can be hold
-* *org.apache.wicket.pageStore.memory.MemorySizeEvictionStrategy* - specifies the maximum amount of memory for pages per http session.
-
-To configure it:
-{code}
-MyApp#init()
-{
- super.init();
-
- setPageManagerProvider(new DefaultPageManagerProvider(this)
- {
- protected IDataStore newDataStore()
- {
- return new HttpSessionDataStore(getPageManagerContext(), new PageNumberEvictionStrategy(20));
- }
- }
-}
-{code}
-
-h3. DebugBar
-
-Further insights which can be valueable during debugging can be retrieved using the @org.apache.wicket.devutils.debugbar.DebugBar@ from wicket-devutils.jar. It's a panel which you simply add:
-
-Java:
-{code}
-add(new DebugBar("debug"));
-{code}
-
-HTML:
-{code}
-<span wicket:id="debug"/>
-{code}
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/introduction.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/introduction.gdoc b/wicket-user-guide/src/docs/guide/introduction.gdoc
deleted file mode 100644
index 43ea7dd..0000000
--- a/wicket-user-guide/src/docs/guide/introduction.gdoc
+++ /dev/null
@@ -1,24 +0,0 @@
-Wicket has been around since 2004 and it has been an Apache project since 2007. During these years it has proved to be a solid and valuable solution for building enterprise web applications.
-
-Wicket core developers have done a wonderful job with this framework and they continue to improve it release after release.
-However Wicket never provided a freely available documentation and even if you can find on Internet many live examples and many technical articles on it (most of them at {externalink:wicket.examples.url}Wicket Examples Site{externalink} and at "Wicket in Action":http://wicketinaction.com ), the lack of an organized and freely available documentation has always been a sore point for this framework.
-
-That's quite an issue because many other popular frameworks (like Spring, Hibernate or Struts) offer a vast and very good documentation which substantially contributed to their success.
-
-This document is not intended to be a complete reference for Wicket but it simply aims to be a straightforward introduction to the framework that should significantly reduce its learning curve. What you will find here reflects my experience with Wicket and it's strictly focused on the framework.
-The various Wicket-related topics are gradually introduced using pragmatic examples of code that you can find in "the according repository on Github.":https://github.com/bitstorm/Wicket-tutorial-examples
-
-However remember that Wicket is a vast and powerful tool, so you should feel confident with the topics exposed in this document before starting to code your real applications!
-
-For those who need further documentation on Wicket, there are "many good books":http://wicket.apache.org/learn/books/ available for this framework.
-
-Hope you'll find this guide helpful. Have fun with Wicket!
-
-*Andrea Del Bene, adelbene@apache.org*
-
-*PS*: this guide is based on Wicket 6. However if you are using an older version you should find this guide useful as well, but it's likely that the code and the snippets won't work with your version.
-
-*PPS*: although I've tried to do my best working on this tutorial, this document is a work in progress and may contain errors and/or omissions. That's why any feedback of any kind is REALLY appreciated!
-
-Project started by "!comsysto-logo.png!":http://comsysto.com/
-
http://git-wip-us.apache.org/repos/asf/wicket/blob/7eba9998/wicket-user-guide/src/docs/guide/jee.gdoc
----------------------------------------------------------------------
diff --git a/wicket-user-guide/src/docs/guide/jee.gdoc b/wicket-user-guide/src/docs/guide/jee.gdoc
deleted file mode 100644
index 97ace94..0000000
--- a/wicket-user-guide/src/docs/guide/jee.gdoc
+++ /dev/null
@@ -1,11 +0,0 @@
-Writing a web application is not just about producing a good layout and a bunch of \u201ccool\u201d pages. We must also integrate our presentation code with enterprise resources like data sources, message queues, business objects, etc...
-
-The first decade of 2000s has seen the rising of new frameworks (like "Spring":http://spring.io/ ) and new specifications (like "EJB 3.1":http://en.wikipedia.org/wiki/Enterprise_JavaBeans ) aimed to simplify the management of enterprise resources and (among other things) their integration with presentation code.
-
-All these new technologies are based on the concepts of container and dependency injection. Container is the environment where our enterprise resources are created and configured while "dependency injection":http://en.wikipedia.org/wiki/Dependency_Injection is a pattern implemented by containers to inject into an object the resources it depends on.
-
-Wicket can be easily integrated with enterprise containers using component instantiation listeners. These entities are instances of interface @org.apache.wicket.application.IComponentInstantiationListener@ and can be registered during application's initialization. IComponentInstantiationListener defines callback method onInstantiation(Component component) which can be used to provide custom instantiation logic for Wicket components.
-
-Wicket distribution and project "WicketStuff":https://github.com/wicketstuff already provide a set of built-in listeners to integrate our applications with EJB 3.1 compliant containers (like JBoss Seam) or with some of the most popular enterprise frameworks like "Guice":http://code.google.com/p/google-guice/ or Spring.
-
-In this chapter we will see two basic examples of injecting a container-defined object into a page using first an implementation of the EJB 3.1 specifications (project "OpenEJB":http://openejb.apache.org/ ) and then using Spring.
\ No newline at end of file