svn commit: r1744249 [2/3] - in /velocity/site/cms/trunk/content: ./ anakia/1.0/ engine/1.7/ engine/devel/ tools/2.0/ tools/devel/ tools/devel/maven-velocity-tools-plugin/images/

[cb...@apache.org]

Modified: velocity/site/cms/trunk/content/tools/2.0/tools-summary.mdtext
URL: http://svn.apache.org/viewvc/velocity/site/cms/trunk/content/tools/2.0/tools-summary.mdtext?rev=1744249&r1=1744248&r2=1744249&view=diff
==============================================================================
--- velocity/site/cms/trunk/content/tools/2.0/tools-summary.mdtext (original)
+++ velocity/site/cms/trunk/content/tools/2.0/tools-summary.mdtext Tue May 17 10:44:17 2016
@@ -38,20 +38,20 @@ You will find here a summary of all the
 
 #### Struts Tools
 
-+ [ActionMessagesTool](javadoc/org/apache/velocity/tools/struts/ActionMessagesTool.html),
-+ [ErrorsTool](javadoc/org/apache/velocity/tools/struts/ErrorsTool.html),
-+ [FormTool](javadoc/org/apache/velocity/tools/struts/FormTool.html),
-+ [MessageResourcesTool](javadoc/org/apache/velocity/tools/struts/MessageResourcesTool.html),
-+ [MessageTool](javadoc/org/apache/velocity/tools/struts/MessageTool.html),
-+ [SecureLinkTool](javadoc/org/apache/velocity/tools/struts/SecureLinkTool.html),
-+ [StrutsLinkTool](javadoc/org/apache/velocity/tools/struts/StrutsLinkTool.html),
-+ [TilesTool](javadoc/org/apache/velocity/tools/struts/TilesTool.html),
-+ [ValidatorTool](javadoc/org/apache/velocity/tools/struts/ValidatorTool.html)
++ [ActionMessagesTool](apidocs/org/apache/velocity/tools/struts/ActionMessagesTool.html),
++ [ErrorsTool](apidocs/org/apache/velocity/tools/struts/ErrorsTool.html),
++ [FormTool](apidocs/org/apache/velocity/tools/struts/FormTool.html),
++ [MessageResourcesTool](apidocs/org/apache/velocity/tools/struts/MessageResourcesTool.html),
++ [MessageTool](apidocs/org/apache/velocity/tools/struts/MessageTool.html),
++ [SecureLinkTool](apidocs/org/apache/velocity/tools/struts/SecureLinkTool.html),
++ [StrutsLinkTool](apidocs/org/apache/velocity/tools/struts/StrutsLinkTool.html),
++ [TilesTool](apidocs/org/apache/velocity/tools/struts/TilesTool.html),
++ [ValidatorTool](apidocs/org/apache/velocity/tools/struts/ValidatorTool.html)
 
 ### Generic Tools
 
 
-#### [**AlternatorTool**](javadoc/org/apache/velocity/tools/generic/AlternatorTool.html){#AlternatorTool} - tool to create [alternators](javadoc/org/apache/velocity/tools/generic/Alternator.java) (variables that cycle through an array)
+#### [**AlternatorTool**](apidocs/org/apache/velocity/tools/generic/AlternatorTool.html){#AlternatorTool} - tool to create [alternators](apidocs/org/apache/velocity/tools/generic/Alternator.html) (variables that cycle through an array)
 
 **`$alternator`** |
 --|--
@@ -66,7 +66,7 @@ You will find here a summary of all the
 `$alt.shift` | shifts to next value
 `$alt.auto` | read/write property stating if this is an automatic alternator
 
-#### [**ClassTool**](javadoc/org/apache/velocity/tools/generic/ClassTool.html) - tool meant to use Java reflection in templates{#ClassTool}
+#### [**ClassTool**](apidocs/org/apache/velocity/tools/generic/ClassTool.html) - tool meant to use Java reflection in templates{#ClassTool}
 
 **`$class`** | 
 --|--
@@ -74,10 +74,10 @@ You will find here a summary of all the
 `config.safeMode` [ = `true` ] | boolean, indicates whether to only show public members, fields and constructors
 `config.showDeprecated` [ = `false` ] | boolean, states whether deprecated members, fields and constructors are to be shown
 `$class.annotations` | returns a list of the [`Annotations`](http://java.sun.com/j2se/1.5.0/docs/api/java/lang/annotation/Annotation.html) of the class being inspected
-`$class.constructors` | returns a list of [`ConstructorSub`](javadoc/org/apache/velocity/tools/generic/ClassTool.ConstructorSub.html)s for each constructor declared in the inspected class, with the following methods and read-only properties: `$ctor.name`, `$ctor.parameters` (array of `Class`), `$ctor.isVarArgs()`, `$ctor.modifiers` (some were omitted)
-`$class.field` | returns a list of [`FieldSub`](org/apache/velocity/tools/generic/ClassTool.FieldSub.html)s for each field declared in the inspected class, with the following read-only properties: `$field.name`, `$field.modifiers`, `$field.staticValue`, `$field.type` (some were omitted)
+`$class.constructors` | returns a list of [`ConstructorSub`](apidocs/org/apache/velocity/tools/generic/ClassTool.ConstructorSub.html)s for each constructor declared in the inspected class, with the following methods and read-only properties: `$ctor.name`, `$ctor.parameters` (array of `Class`), `$ctor.isVarArgs()`, `$ctor.modifiers` (some were omitted)
+`$class.field` | returns a list of [`FieldSub`](apidocs/org/apache/velocity/tools/generic/ClassTool.FieldSub.html)s for each field declared in the inspected class, with the following read-only properties: `$field.name`, `$field.modifiers`, `$field.staticValue`, `$field.type` (some were omitted)
 `$class.fullName` | full name of the inspected class
-`$class.methods` | returns a list of [`MethodSub`](org/apache/velocity/tools/generic/ClassTool.MethodSub.html)s for each method declared in the inspected class, with the following methods and read-only properties: `$method.name`, `$method.parameters` (array of `Class`), `$method.returns`, `$method.isVarArgs()`, `$method.modifiers`, `$method.propertyName` (If this method can be treated as a bean property in Velocity, then it will return the "bean property" equivalent of the method name), `$method.isVoid()` (some were omitted)
+`$class.methods` | returns a list of [`MethodSub`](apidocs/org/apache/velocity/tools/generic/ClassTool.MethodSub.html)s for each method declared in the inspected class, with the following methods and read-only properties: `$method.name`, `$method.parameters` (array of `Class`), `$method.returns`, `$method.isVarArgs()`, `$method.modifiers`, `$method.propertyName` (If this method can be treated as a bean property in Velocity, then it will return the "bean property" equivalent of the method name), `$method.isVoid()` (some were omitted)
 `$class.name` | returns the simple name of the class being inspected
 `$class.package` | returns the package name of the class being inspected
 `$class.showDeprecated` | returns or sets the current showDeprecated setting
@@ -90,7 +90,7 @@ You will find here a summary of all the
 `$class.interface` | returns true if the class being inspected is an interface
 `$class.supportsNewInstance()` | returns true if a new instance of the class being inspected can be created via `$class.type.newInstance()`
 
-#### [**ContextTool**](javadoc/org/apache/velocity/tools/generic/ContextTool.html) - tool allowing Velocity context introspection{#ContextTool}
+#### [**ContextTool**](apidocs/org/apache/velocity/tools/generic/ContextTool.html) - tool allowing Velocity context introspection{#ContextTool}
 
 **`$context`** |
 --|--
@@ -100,7 +100,7 @@ You will find here a summary of all the
 `$context.values` | returns a `java.util.Set` of the values available in the current request context
 `$context.get(` *key* `)` | returns the value for the specified key in the current request context
 
-#### [**ConversionTool**](javadoc/org/apache/velocity/tools/generic/ConversionTool.html) - tool allowing conversions between datatypes{#ConversionTool}
+#### [**ConversionTool**](apidocs/org/apache/velocity/tools/generic/ConversionTool.html) - tool allowing conversions between datatypes{#ConversionTool}
 
 **`$convert`** |
 --|--
@@ -117,11 +117,11 @@ You will find here a summary of all the
 `$convert.to`*Type*`(` *object* `)` | converts an object to an instance of *Type*, where *Type* can be one of `Boolean`, `Calendar`, `Date`, `Double`, `Integer`, `Locale`, `Number`, `String`
 `$convert.to`*Type*`s(` *object* `)` | converts an array, Collection, delimited String, or object to an array of *Type*s, where *Type* can be one of `Boolean`, `Calendar`, `Date`, `Double`, `Integer`, `Locale`, `Number`, `String`
 
-#### [**ComparisonDateTool**](javadoc/org/apache/velocity/tools/generic/ComparisonDateTool.html) - tool used to format, parse and compare dates{#ComparisonDateTool}
+#### [**ComparisonDateTool**](apidocs/org/apache/velocity/tools/generic/ComparisonDateTool.html) - tool used to format, parse and compare dates{#ComparisonDateTool}
 
 **`$date`** | 
 --|--
-`config.format` = [ JVM Locale default format ] | default format (see [formatting patterns](javadoc/org/apache/velocity/tools/generic/DateTool.html#format(java.lang.String, java.lang.Object, java.util.Locale, java.util.TimeZone)))
+`config.format` = [ JVM Locale default format ] | default format (see [formatting patterns](apidocs/org/apache/velocity/tools/generic/DateTool.html#format(java.lang.String, java.lang.Object, java.util.Locale, java.util.TimeZone)))
 `config.locale` = [ JVM Locale ] | default locale
 `config.timezone` = [ JVM timezone ] | time zone
 `$date` | returns the current date and time formatted with the default format
@@ -140,8 +140,8 @@ You will find here a summary of all the
 `$date.systemDate` | gets the Date at the time this page was rendered for the system running this application
 `$date.toCalendar(` *object* `)` | converts the given object to a java.util.Calendar
 `$date.toDate(` *object* `)` | convers the given object to a java.util.Date
-`$date.whenIs(` *object* `)` | returns a [`ComparisonDateTool.Comparison`](javadoc/org/apache/velocity/tools/generic/ComparisonDateTool.Comparison.html) between current and specified date ; returned comparison will have properties like: `$comp.years`, `$comp.months`, `$comp.weeks`, `$comp.days`, `$comp.hours`, `$comp.minutes`, `$comp.seconds`, `$comp.milliseconds`, along with several other formatting methods
-`$date.whenIs(` *object*, *object* `)` | returns a [`ComparisonDateTool.Comparison`](javadoc/org/apache/velocity/tools/generic/ComparisonDateTool.Comparison.html) between the two specified dates ; returned comparison will have properties like: `$comp.years`, `$comp.months`, `$comp.weeks`, `$comp.days`, `$comp.hours`, `$comp.minutes`, `$comp.seconds`, `$comp.milliseconds`, along with several other formatting methods
+`$date.whenIs(` *object* `)` | returns a [`ComparisonDateTool.Comparison`](apidocs/org/apache/velocity/tools/generic/ComparisonDateTool.Comparison.html) between current and specified date ; returned comparison will have properties like: `$comp.years`, `$comp.months`, `$comp.weeks`, `$comp.days`, `$comp.hours`, `$comp.minutes`, `$comp.seconds`, `$comp.milliseconds`, along with several other formatting methods
+`$date.whenIs(` *object*, *object* `)` | returns a [`ComparisonDateTool.Comparison`](apidocs/org/apache/velocity/tools/generic/ComparisonDateTool.Comparison.html) between the two specified dates ; returned comparison will have properties like: `$comp.years`, `$comp.months`, `$comp.weeks`, `$comp.days`, `$comp.hours`, `$comp.minutes`, `$comp.seconds`, `$comp.milliseconds`, along with several other formatting methods
 
 #### [**DisplayTool**] - tool providing a variety of methods for controlling the output displayed by various references in your templates{#DisplayTool}
 
@@ -180,7 +180,7 @@ You will find here a summary of all the
 `$display.truncate(` *object* [ , *size* ] [ , *suffix* ] `)` | limits the string output of the first argument to the specified or default number of characters. If the string gets curtailed, the specified or default suffix is used as the ending of the truncated string
 `$display.uncapitalize(` *object* `)` | changes the first character of the string value of the specified object to lower case and returns the resulting string
 
-#### [**EscapeTool**](javadoc/org/apache/velocity/tools/generic/EscapeTool.html) - tool providing some escaping facilities{#EscapeTool}
+#### [**EscapeTool**](apidocs/org/apache/velocity/tools/generic/EscapeTool.html) - tool providing some escaping facilities{#EscapeTool}
 
 **`$esc`** |
 --|--
@@ -199,7 +199,7 @@ You will find here a summary of all the
 `$esc.propertyKey(` *string* `)` | escapes the characters in a String using java.util.Properties rules for escaping keys
 `$esc.propertyValue(` *string* `)` | escapes the characters in a String using java.util.Properties rules for escaping values
 
-#### [**FieldTool**](javadoc/org/apache/velocity/tools/generic/FieldTool.html) - tool allowing easy access to public static fields in classes, such as string constants{#FieldTool}
+#### [**FieldTool**](apidocs/org/apache/velocity/tools/generic/FieldTool.html) - tool allowing easy access to public static fields in classes, such as string constants{#FieldTool}
 
 **`$field`** |
 --|--
@@ -208,7 +208,7 @@ You will find here a summary of all the
 `$field.get(` *string* `)` | returns the value of the field with the specified name, if found
 `$fields.in(` *class/object/string* `)` | loads all public static fields in the specified class or object
 
-#### [**LinkTool**](javadoc/org/apache/velocity/tools/generic/LinkTool.html) - tool used to format hyperlinks ; this tool is somewhat unusual in that every method that takes parameters will return a new instance of the tool that is a copy of the one the method was called upon, with the additional change specified by the method call, allowing for chained calls like `href="$link.relative('foobar.html').param('id','25').anchor('section4')"` (which would produce `href="foobar.html?id=25#section4"`){#LinkTool}
+#### [**LinkTool**](apidocs/org/apache/velocity/tools/generic/LinkTool.html) - tool used to format hyperlinks ; this tool is somewhat unusual in that every method that takes parameters will return a new instance of the tool that is a copy of the one the method was called upon, with the additional change specified by the method call, allowing for chained calls like `href="$link.relative('foobar.html').param('id','25').anchor('section4')"` (which would produce `href="foobar.html?id=25#section4"`){#LinkTool}
 
 **`$link`** |
 --|--
@@ -240,7 +240,7 @@ You will find here a summary of all the
 `$link.encode(` *string* `)` | performs URL encoding on the specified text
 `$link` | displays link
 
-#### [**MathTool**](javadoc/org/apache/velocity/tools/generic/MathTool.html) - tool providing math functions{#MathTool}
+#### [**MathTool**](apidocs/org/apache/velocity/tools/generic/MathTool.html) - tool providing math functions{#MathTool}
 
 **`$math`** |
 --|--
@@ -264,7 +264,7 @@ You will find here a summary of all the
 `$math.toDouble(` *object* `)` | converts an object with a numeric value into a `Double` ; valid formats are `Number` or a string representation of a number
 `$math.toNumber(` *object* `)` | converts an object with a numeric value into a `Number` ; valid formats are `Number` or a string representation of a number
 
-#### [**NumberTool**](javadoc/org/apache/velocity/tools/generic/NumberTool.html) - tool used to format numbers{#NumberTool}
+#### [**NumberTool**](apidocs/org/apache/velocity/tools/generic/NumberTool.html) - tool used to format numbers{#NumberTool}
 
 **`$number`** |
 --|--
@@ -278,7 +278,7 @@ You will find here a summary of all the
 `$number.number(` *object* `)` | convenience method equivalent to `$number.format("number", $foo)`
 `$number.percent(` *object* `)` | convenience method equivalent to `$number.format("percent", $foo)`
 
-#### [**RenderTool**](javadoc/org/apache/velocity/tools/generic/RenderTool.html" name="RenderTool">RenderTool) - tool that exposes methods to evaluate the given strings as VTL (Velocity Template Language) using either a pre-configured context or one you provide directly{#RenderTool}
+#### [**RenderTool**](apidocs/org/apache/velocity/tools/generic/RenderTool.html) - tool that exposes methods to evaluate the given strings as VTL (Velocity Template Language) using either a pre-configured context or one you provide directly{#RenderTool}
 
 **`$render`** |
 --|--
@@ -288,13 +288,13 @@ You will find here a summary of all the
 `$render.eval(` *string* `)` | evaluates a String containing VTL using the current context, and returns the result as a String
 `$render.recurse(` *string* `)` | recursively evaluates a String containing VTL using the current context, and returns the result as a String
 
-#### [**SortTool**](javadoc/org/apache/velocity/tools/generic/SortTool.html) - tool used to sort collections{#SortTool}
+#### [**SortTool**](apidocs/org/apache/velocity/tools/generic/SortTool.html) - tool used to sort collections{#SortTool}
 
 **`$sort`** |
 --|--
 `$sorter.sort(` *collection* [ , *property  / property list* ] `)` | sorts the values of the specified `Collection`, `Map`, or array of `Objects`, either by their natural order or  according to the values returned by the specified property or list of properties
 
-#### [**ResourceTool**](javadoc/org/apache/velocity/tools/generic/ResourceTool.html) - tool for accessing ResourceBundles and formatting messages therein ;  most methods return a new object that has mostly the same methods as the original, allowing you to build up parameters elegantly and simply, rather than try to remember how to use methods with many parameters that must be in a specific order: so, you can access a resource with the key `'hello.whoever'` in the `'otherStuff'` bundle with one message argument like this: `$text.hello.whoever.bundle('otherStuff').insert('World')` instead of like this: `$text.get('hello.whoever','otherStuff', $null, 'World')`{#ResourceTool}
+#### [**ResourceTool**](apidocs/org/apache/velocity/tools/generic/ResourceTool.html) - tool for accessing ResourceBundles and formatting messages therein ;  most methods return a new object that has mostly the same methods as the original, allowing you to build up parameters elegantly and simply, rather than try to remember how to use methods with many parameters that must be in a specific order: so, you can access a resource with the key `'hello.whoever'` in the `'otherStuff'` bundle with one message argument like this: `$text.hello.whoever.bundle('otherStuff').insert('World')` instead of like this: `$text.get('hello.whoever','otherStuff', $null, 'World')`{#ResourceTool}
 
 **`$text`** |
 --|--
@@ -309,7 +309,7 @@ You will find here a summary of all the
 `$text.`*key*`.insert(` *value* [ , *value* ... ] `)` | returns the named resource with the specified values inserted
 `$text.locale` | returns or sets the current locale
 
-#### [**XmlTool**](javadoc/org/apache/velocity/tools/generic/XmlTool.html) - tool used for reading/navigating XML files; this uses dom4j under the covers to provide complete XPath support for traversing XML files{#XmlTool}
+#### [**XmlTool**](apidocs/org/apache/velocity/tools/generic/XmlTool.html) - tool used for reading/navigating XML files; this uses dom4j under the covers to provide complete XPath support for traversing XML files{#XmlTool}
 
 **`$xml`** |
 --|--
@@ -338,7 +338,7 @@ You will find here a summary of all the
 
 ### View Tools
 
-#### [**BrowserTool**](javadoc/org/apache/velocity/tools/view/BrowserTool.html) - browser-sniffing tool; it defines properties that are used to test the client browser, operating system, device, language... apart from properties related to browser version and language, all properties are booleans.{#BrowserTool}
+#### [**BrowserTool**](apidocs/org/apache/velocity/tools/view/BrowserTool.html) - browser-sniffing tool; it defines properties that are used to test the client browser, operating system, device, language... apart from properties related to browser version and language, all properties are booleans.{#BrowserTool}
 
 **`$browser`** |
 --|--
@@ -358,13 +358,13 @@ You will find here a summary of all the
 `$browser.preferredLanguageTag` | returns the browser's preferred langage tag (a string like 'en', 'da', 'en-US', ...), optionnaly affected by the languagesFilter configuration property
 `$browser.preferredLocale` | returns the browser's preferred locale
 
-#### [**ViewContextTool**](javadoc/org/apache/velocity/tools/view/ViewContextTool.html) - extension of the generic ContextTool that includes keys and values from the HttpServletRequest, HttpSession and ServletContext attributes; inherits all methods and properties from the generic [`ContextTool`](#ContextTool){#ViewContextTool}
+#### [**ViewContextTool**](apidocs/org/apache/velocity/tools/view/ViewContextTool.html) - extension of the generic ContextTool that includes keys and values from the HttpServletRequest, HttpSession and ServletContext attributes; inherits all methods and properties from the generic [`ContextTool`](#ContextTool){#ViewContextTool}
 
 **`$context`** |
 --|--
 **scope** | request
 
-#### [**CookieTool**](javadoc/org/apache/velocity/tools/view/CookieTool.html) - tool used to read and set cookies{#CookieTool}
+#### [**CookieTool**](apidocs/org/apache/velocity/tools/view/CookieTool.html) - tool used to read and set cookies{#CookieTool}
 
 **`$cookies`** |
 --|--
@@ -377,14 +377,14 @@ You will find here a summary of all the
 `$cookies.`*name*, `$cookies.get(` *name* `)` | returns the Cookie with the specified name, if it exists
 `$cookies` | if there are no Cookies in the request, this returns the standard Object.toString output; otherwise, it returns a pretty printed list of cookie names and values
 
-#### [**ImportTool**](javadoc/org/apache/velocity/tools/view/ImportTool.html) - general-purpose text-importing view tool for templates{#ImportTool}
+#### [**ImportTool**](apidocs/org/apache/velocity/tools/view/ImportTool.html) - general-purpose text-importing view tool for templates{#ImportTool}
 
 **`$import`** |
 --|--
 **scope** | request
 `$import.read(` *url* `)` | returns the content read from the specified URL
 
-#### [**IncludeTool**](javadoc/org/apache/velocity/tools/view/IncludeTool.html) - tool allowing for transparent content negotiation in a manner mimicking Apache httpd's MultiViews; reads the default language out of the ViewToolContext as `org.apache.velocity.tools.view.i18n.defaultLanguage`; please note that it does NOT do the actual `#include` or `#parse` for you, but is merely to aid in include content negotiation{#IncludeTool}
+#### [**IncludeTool**](apidocs/org/apache/velocity/tools/view/IncludeTool.html) - tool allowing for transparent content negotiation in a manner mimicking Apache httpd's MultiViews; reads the default language out of the ViewToolContext as `org.apache.velocity.tools.view.i18n.defaultLanguage`; please note that it does NOT do the actual `#include` or `#parse` for you, but is merely to aid in include content negotiation{#IncludeTool}
 
 **`$include`** |
 --|--
@@ -393,7 +393,7 @@ You will find here a summary of all the
 `$include.exists(` *name* [ , *locale* ] `)` | checks whether or not a resource is available with the specified name and, if provided, specified language suffix
 `$include.find(` *name* [ , *locale / language code* ] `)` | returns the localized name for the specified resource, with the specified Locales language suffix if specified; if one for that language is unavailable, then it will "widen" the language until one is found; if none is found at all, the name parameter is returned
 
-#### [**LinkTool**](javadoc/org/apache/velocity/tools/view/LinkTool.html) - tool used to format hyperlinks ; this tool is somewhat unusual in that every method that takes parameters will return a new instance of the tool that is a copy of the one the method was called upon, with the additional change specified by the method call, allowing for chained calls like `href="$link.relative('foobar.html').param('id','25').anchor('section4')"` (which would produce `href="foobar.html?id=25#section4"`); all methods and properties from the generic [`LinkTool`](#LinkTool) are inherited{#LinkTool2}
+#### [**LinkTool**](apidocs/org/apache/velocity/tools/view/LinkTool.html) - tool used to format hyperlinks ; this tool is somewhat unusual in that every method that takes parameters will return a new instance of the tool that is a copy of the one the method was called upon, with the additional change specified by the method call, allowing for chained calls like `href="$link.relative('foobar.html').param('id','25').anchor('section4')"` (which would produce `href="foobar.html?id=25#section4"`); all methods and properties from the generic [`LinkTool`](#LinkTool) are inherited{#LinkTool2}
 
 **`$link`** |
 --|--
@@ -405,7 +405,7 @@ You will find here a summary of all the
 `$link.addRequestParamsExcept(` [ *exceptThisOne* [ , *andThisOne* ... ] ] `)` | adds all of the current request's parameters to this link's query data except for those whose keys match any of the specified strings
 `$link.addMissingRequestParams(` [ *exceptThisOne* [ , *andThisOne* ... ] ] `)` | adds all of the current request's parameters to this link's query data except for those whose keys match any of the specified strings or already have a value set for them in the current instance
 
-#### [**PagerTool**](javadoc/org/apache/velocity/tools/view/PagerTool.html) - tool for doing request-based pagination of items in an a list
+#### [**PagerTool**](apidocs/org/apache/velocity/tools/view/PagerTool.html) - tool for doing request-based pagination of items in an a list
 
 **`$pager`** |
 --|--
@@ -437,7 +437,7 @@ You will find here a summary of all the
 `$pager.total` | returns the total number of items available
 `$pager.slip` | returns a Sliding List of Indices for Pages of items
 
-#### [**ParameterTool**](javadoc/org/apache/velocity/tools/view/ParameterTool.html) - tool used to parse request parameters{#ParameterTool}
+#### [**ParameterTool**](apidocs/org/apache/velocity/tools/view/ParameterTool.html) - tool used to parse request parameters{#ParameterTool}
 
 **`$params`** |1
 --|--
@@ -456,7 +456,7 @@ You will find here a summary of all the
 `$params.getIntegers(` *name* `)` | returns the parameter(s) with the specified key in an array of java.lang.Integers, if any exist; otherwise, returns `null`
 `$params.all` | returns the map of all parameters available for the current request
 
-#### [**AbstractSearchTool**](javadoc/org/apache/velocity/tools/view/AbstractSearchTool.html) - this tool is meant to be extended by a class defining the `protected List executeQuery(Object crit)` Java method; it allows doing "searching" and robust pagination of search results; the goal here is to provide a simple and uniform API for "search tools" that can be used in velocity templates (or even a standard Search.vm template); in particular, this class provides good support for result pagination and some very simple result caching; also check inherited configuration and properties from [PagerTool](#PagerTool){#AbstractSearchTool}
+#### [**AbstractSearchTool**](apidocs/org/apache/velocity/tools/view/AbstractSearchTool.html) - this tool is meant to be extended by a class defining the `protected List executeQuery(Object crit)` Java method; it allows doing "searching" and robust pagination of search results; the goal here is to provide a simple and uniform API for "search tools" that can be used in velocity templates (or even a standard Search.vm template); in particular, this class provides good support for result pagination and some very simple result caching; also check inherited configuration and properties from [PagerTool](#PagerTool){#AbstractSearchTool}
 
 **`$search`** |
 --|--

Modified: velocity/site/cms/trunk/content/tools/2.0/upgrading.mdtext
URL: http://svn.apache.org/viewvc/velocity/site/cms/trunk/content/tools/2.0/upgrading.mdtext?rev=1744249&r1=1744248&r2=1744249&view=diff
==============================================================================
--- velocity/site/cms/trunk/content/tools/2.0/upgrading.mdtext (original)
+++ velocity/site/cms/trunk/content/tools/2.0/upgrading.mdtext Tue May 17 10:44:17 2016
@@ -28,16 +28,16 @@ The extra packages had proved superfluou
 
 Some specific ones to watch out for are as follows. If you directly referenced:
 
-+ VelocityViewServlet, it is now at [org.apache.velocity.tools.view.VelocityViewServlet](javadoc/org/apache/velocity/tools/view/VelocityViewServlet.html)
-+ VelocityLayoutServlet, it is now at [org.apache.velocity.tools.view.VelocityLayoutServlet](javadoc/org/apache/velocity/tools/view/VelocityLayoutServlet.html)
-+ WebappLoader, it is now at [javadoc/org/apache/velocity/tools/view/WebappResourceLoader.html">org.apache.velocity.tools.view.WebappResourceLoader]
-+ ViewContext, it is now at [org.apache.velocity.tools.view.ViewContext](javadoc/org/apache/velocity/tools/view/ViewContext.html)
-+ ServletLogger, it has been replaced by [org.apache.velocity.tools.view.ServletLogChute](javadoc/org/apache/velocity/tools/view/ServletLogChute.html)
-+ ServletUtils, it is now at [org.apache.velocity.tools.view.ServletUtils](javadoc/org/apache/velocity/tools/view/ServletUtils.html)
-+ BrowserSniffer, it is now at [org.apache.velocity.tools.view.BrowserTool](javadoc/org/apache/velocity/tools/view/BrowserTool.html)
-+ AbstractPagerTool, it is now at [org.apache.velocity.tools.view.PagerTool](javadoc/org/apache/velocity/tools/view/PagerTool.html)
-+ ParameterParser, it is now at [org.apache.velocity.tools.view.ParameterTool](javadoc/org/apache/velocity/tools/view/ParameterTool.html)
-+ ContextTool, it is now at [org.apache.velocity.tools.view.ViewContextTool](javadoc/org/apache/velocity/tools/view/ViewContextTool.html)
++ VelocityViewServlet, it is now at [org.apache.velocity.tools.view.VelocityViewServlet](apidocs/org/apache/velocity/tools/view/VelocityViewServlet.html)
++ VelocityLayoutServlet, it is now at [org.apache.velocity.tools.view.VelocityLayoutServlet](apidocs/org/apache/velocity/tools/view/VelocityLayoutServlet.html)
++ WebappLoader, it is now at [org.apache.velocity.tools.view.WebappResourceLoader](apidocs/org/apache/velocity/tools/view/WebappResourceLoader.html)
++ ViewContext, it is now at [org.apache.velocity.tools.view.ViewContext](apidocs/org/apache/velocity/tools/view/ViewContext.html)
++ ServletLogger, it has been replaced by [org.apache.velocity.tools.view.ServletLogChute](apidocs/org/apache/velocity/tools/view/ServletLogChute.html)
++ ServletUtils, it is now at [org.apache.velocity.tools.view.ServletUtils](apidocs/org/apache/velocity/tools/view/ServletUtils.html)
++ BrowserSniffer, it is now at [org.apache.velocity.tools.view.BrowserTool](apidocs/org/apache/velocity/tools/view/BrowserTool.html)
++ AbstractPagerTool, it is now at [org.apache.velocity.tools.view.PagerTool](apidocs/org/apache/velocity/tools/view/PagerTool.html)
++ ParameterParser, it is now at [org.apache.velocity.tools.view.ParameterTool](apidocs/org/apache/velocity/tools/view/ParameterTool.html)
++ ContextTool, it is now at [org.apache.velocity.tools.view.ViewContextTool](apidocs/org/apache/velocity/tools/view/ViewContextTool.html)
 
 **NOTE:** If you are still using the old toolbox.xml format do NOT update the tool paths in that file!  First, [update your configuration](#Configuration), otherwise your tools may not work as expected. Also, this is not a complete list.  Please take note of all deprecation warnings and notices when compiling and running your app.
 
@@ -47,32 +47,32 @@ Along with the class renamings above hav
 
 **XMLToolboxManager** was the the central tool management class in Tools 1.x.  If you used it or **ServletToolboxManager** you were probably a more advanced user or a framework developer working to integrate VelocityTools support.  If so, you should go read [this document](frameworks.html). If you used XMLToolboxManager directly, you should familiarize yourself with these classes:
 
-+ [ToolManager](javadoc/org/apache/velocity/tools/ToolManager.html)
-+ [ConfigurationUtils](javadoc/org/apache/velocity/tools/config/ConfigurationUtils.html)
-+ [FactoryConfiguration](javadoc/org/apache/velocity/tools/config/FactoryConfiguration.html)
-+ [ToolboxFactory](javadoc/org/apache/velocity/tools/ToolboxFactory.html)
-+ [ToolContext](javadoc/org/apache/velocity/tools/ToolContext.html)
++ [ToolManager](apidocs/org/apache/velocity/tools/ToolManager.html)
++ [ConfigurationUtils](apidocs/org/apache/velocity/tools/config/ConfigurationUtils.html)
++ [FactoryConfiguration](apidocs/org/apache/velocity/tools/config/FactoryConfiguration.html)
++ [ToolboxFactory](apidocs/org/apache/velocity/tools/ToolboxFactory.html)
++ [ToolContext](apidocs/org/apache/velocity/tools/ToolContext.html)
                 
 If you used ServletToolboxManager directly, you should learn about all of the above classes (except perhaps ToolManager) and the following ones as well:
 
-+ [VelocityView](javadoc/org/apache/velocity/tools/view/VelocityView.html)
-+ [ViewToolContext](javadoc/org/apache/velocity/tools/view/ViewToolContext.html)
-+ [ServletUtils](javadoc/org/apache/velocity/tools/view/ServletUtils.html)
++ [VelocityView](apidocs/org/apache/velocity/tools/view/VelocityView.html)
++ [ViewToolContext](apidocs/org/apache/velocity/tools/view/ViewToolContext.html)
++ [ServletUtils](apidocs/org/apache/velocity/tools/view/ServletUtils.html)
 
-**NOTE:** For the vast majority of users and developers, [ToolManager](javadoc/org/apache/velocity/tools/ToolManager.html) or [VelocityView](javadoc/org/apache/velocity/tools/view/VelocityView.html) should be all they really need to work with directly.  Don't waste time trying to manage <code>Toolbox</code> es yourself until you are sure that ToolManager/VelocityView can't do the job for you.
+**NOTE:** For the vast majority of users and developers, [ToolManager](apidocs/org/apache/velocity/tools/ToolManager.html) or [VelocityView](apidocs/org/apache/velocity/tools/view/VelocityView.html) should be all they really need to work with directly.  Don't waste time trying to manage <code>Toolbox</code> es yourself until you are sure that ToolManager/VelocityView can't do the job for you.
 
 All of the upgrades to tool management allowed some GenericTool classes to perform functions previously only possible to implement in VelocityView tools.  As such, some VelocityView subclasses of generic tools have become obsolete.  If you used:
 
-+ ViewRenderTool, you should now just use [`org.apache.velocity.tools.generic.RenderTool`](javadoc/org/apache/velocity/tools/generic/RenderTool.html)
-+ ViewResourceTool, you should now just use [`org.apache.velocity.tools.generic.ResourceTool`](javadoc/org/apache/velocity/tools/generic/ResourceTool.html)
++ ViewRenderTool, you should now just use [`org.apache.velocity.tools.generic.RenderTool`](apidocs/org/apache/velocity/tools/generic/RenderTool.html)
++ ViewResourceTool, you should now just use [`org.apache.velocity.tools.generic.ResourceTool`](apidocs/org/apache/velocity/tools/generic/ResourceTool.html)
 
 ### Configuration in 2.0
 
-Since Tools 2 does lazy-loading of tools, it now makes sense to have almost all tools available by default for most uses, as there is minimal overhead for that at startup and essentially no cost at runtime unless/until the tool is used. So, in Tools 2, unless the user is doing something to trigger the "deprecation support mode" for VelocityView (using the old toolbox.xml format would do this) or explicitly telling [VelocityView](javadoc/org/apache/velocity/tools/view/VelocityView.html) not to load the default tools, then all of the supported, standard VelocityTools will be automatically made available by default.  If you don't custom configure any of the provided tools and don't have any custom tools of your own, then you don't actually need a configuration at all! Tools 2 comes with a default tools.xml file each for GenericTools, VelocityView and VelocityStruts, and the [ToolManager](javadoc/org/apache/velocity/tools/ToolManager.html), [VelocityViewServlet](javadoc/org/apache/veloc
 ity/tools/view/VelocityViewServlet.html), [VelocityLayoutServlet](javadoc/org/apache/velocity/tools/view/VelocityLayoutServlet.html) and [VelocityViewTag](javadoc/org/apache/velocity/tools/view/jsp/VelocityViewTag.html) will all automatically look for and load those unless you are using a deprecated toolbox.xml file or explicitly tell them not to by adding the init-param `org.apache.velocity.tools.loadDefaults` with the value of false to the relevant servlet.
+Since Tools 2 does lazy-loading of tools, it now makes sense to have almost all tools available by default for most uses, as there is minimal overhead for that at startup and essentially no cost at runtime unless/until the tool is used. So, in Tools 2, unless the user is doing something to trigger the "deprecation support mode" for VelocityView (using the old toolbox.xml format would do this) or explicitly telling [VelocityView](apidocs/org/apache/velocity/tools/view/VelocityView.html) not to load the default tools, then all of the supported, standard VelocityTools will be automatically made available by default.  If you don't custom configure any of the provided tools and don't have any custom tools of your own, then you don't actually need a configuration at all! Tools 2 comes with a default tools.xml file each for GenericTools, VelocityView and VelocityStruts, and the [ToolManager](apidocs/org/apache/velocity/tools/ToolManager.html), [VelocityViewServlet](apidocs/org/apache/veloc
 ity/tools/view/VelocityViewServlet.html), [VelocityLayoutServlet](apidocs/org/apache/velocity/tools/view/VelocityLayoutServlet.html) and [VelocityViewTag](apidocs/org/apache/velocity/tools/view/jsp/VelocityViewTag.html) will all automatically look for and load those unless you are using a deprecated toolbox.xml file or explicitly tell them not to by adding the init-param `org.apache.velocity.tools.loadDefaults` with the value of false to the relevant servlet.
 
 If you do need a configuration, you should update your configuration to one of the new formats.  Easiest would be to go from the old xml format to [the new xml format](config-xml.html). Remember, you can just leave out standard tools that you don't do any configuration of, as your configuration will just be added to the default one (again, unless the default behavior is turned off). Also, do note that all VelocityView tools have [changed packages and/or names](#Renamings-in-2.0); please avoid using the deprecated versions as those will eventually be removed.
 
-If you are largely happy with the default tools.xml configuration, but wish to override just a few parts, you can override them with your own file. Tool configurations are key-centric.  If you just want to provide a different default format for the [DateTool](javadoc/org/apache/velocity/tools/generic/DateTool.html) and a second bundle for the ResourceTool, your tools.xml can be just:
+If you are largely happy with the default tools.xml configuration, but wish to override just a few parts, you can override them with your own file. Tool configurations are key-centric.  If you just want to provide a different default format for the [DateTool](apidocs/org/apache/velocity/tools/generic/DateTool.html) and a second bundle for the ResourceTool, your tools.xml can be just:
 
     <tools>
       <toolbox scope="application">
@@ -95,11 +95,11 @@ Please see the [framework integration](f
 
 Those of you who write your own custom tools may want to make a few changes to upgrade your custom tools to do things the "Tools 2 way".  Here's a few quick starts for that, though this doesn't cover everything.  More details can be found in the [instructions for creating tools](creating-tools.html).
 
-**Naming:** The recommended practice is to give a tool to be used as `$foo` the name `FooTool` . This is not required but is a convention that keeps things easy follow and learn.  If you have to name a tool FooBarUtility but want it to be `$foo` in templates, the second best thing is to provide a [`@DefaultKey("foo")`](javadoc/org/apache/velocity/tools/config/DefaultKey.html) annotation on the class, though this introduces a dependency on VelocityTools. As a last resort, if you are providing tools for a framework or otherwise can influence or control the configuration, you might consider providing a default configuration -- perhaps even one automatically discoverable by [ConfigurationUtils](javadoc/org/apache/velocity/tools/config/ConfigurationUtils.html) -- to set the tool's key for your users.
+**Naming:** The recommended practice is to give a tool to be used as `$foo` the name `FooTool` . This is not required but is a convention that keeps things easy follow and learn.  If you have to name a tool FooBarUtility but want it to be `$foo` in templates, the second best thing is to provide a [`@DefaultKey("foo")`](apidocs/org/apache/velocity/tools/config/DefaultKey.html) annotation on the class, though this introduces a dependency on VelocityTools. As a last resort, if you are providing tools for a framework or otherwise can influence or control the configuration, you might consider providing a default configuration -- perhaps even one automatically discoverable by [ConfigurationUtils](apidocs/org/apache/velocity/tools/config/ConfigurationUtils.html) -- to set the tool's key for your users.
 
-**Scoping:** If your tool is only meant to be used in a particular scope, it's recommended that you give the class a [`@ValidScope(Scope.REQUEST)`](javadoc/org/apache/velocity/tools/config/ValidScope.html) annotation as well. If you only want to ban a particular scope and allow all others, you could provide a [`@InvalidScope(Scope.APPLICATION)`](javadoc/org/apache/velocity/tools/config/InvalidScope.html) annotation on the class. The [`Scope`](javadoc/org/apache/velocity/tools/Scope.html) class provides constants for REQUEST, SESSION, and APPLICATION. Other scopes are now theoretically possible, but only a little work and no testing has been done there at this point.
+**Scoping:** If your tool is only meant to be used in a particular scope, it's recommended that you give the class a [`@ValidScope(Scope.REQUEST)`](apidocs/org/apache/velocity/tools/config/ValidScope.html) annotation as well. If you only want to ban a particular scope and allow all others, you could provide a [`@InvalidScope(Scope.APPLICATION)`](apidocs/org/apache/velocity/tools/config/InvalidScope.html) annotation on the class. The [`Scope`](apidocs/org/apache/velocity/tools/Scope.html) class provides constants for REQUEST, SESSION, and APPLICATION. Other scopes are now theoretically possible, but only a little work and no testing has been done there at this point.
 
-**Configuration:** If you have a configurable tool whose configuration should not changed by the templates which use it, then consider having your tool extend the [SafeConfig](javadoc/org/apache/velocity/tools/generic/SafeConfig.html) class (or [FormatConfig](javadoc/org/apache/velocity/tools/generic/FormatConfig.html) or [LocaleConfig](javadoc/org/apache/velocity/tools/generic/LocaleConfig.html)). These safely standardize configuration of these common configuration properties. Also take note that the `configure(Map)` and `init(Object)` methods have been changed into just the `configure(Map)` and individual setter methods (e.g. `setRequest`, `setSession`, etc).  Basically, when it's time to instantiate a tool, the tool manager will gather all the "configuration properties" for that tool, its toolbox, etc and combine it into a single map with the "init data" (context, request, session, etc).  The manager searches for relevant setter methods that accept that data and also for a `confi
 gure(Map)` method. The setters get what they're asking for (if available) and the `configure()` method accepts the whole combined `Map`. The upshot of this approach is that tools no longer need to conform to any interfaces or patterns. In fact, it's possible to write a FooTool that doesn't know anything about any VelocityTools classes whatsoever and yet be fully instantiable and configurable by VelocityTools. Your tools don't need to know about anything except what they need to know about.
+**Configuration:** If you have a configurable tool whose configuration should not changed by the templates which use it, then consider having your tool extend the [SafeConfig](apidocs/org/apache/velocity/tools/generic/SafeConfig.html) class (or [FormatConfig](apidocs/org/apache/velocity/tools/generic/FormatConfig.html) or [LocaleConfig](apidocs/org/apache/velocity/tools/generic/LocaleConfig.html)). These safely standardize configuration of these common configuration properties. Also take note that the `configure(Map)` and `init(Object)` methods have been changed into just the `configure(Map)` and individual setter methods (e.g. `setRequest`, `setSession`, etc).  Basically, when it's time to instantiate a tool, the tool manager will gather all the "configuration properties" for that tool, its toolbox, etc and combine it into a single map with the "init data" (context, request, session, etc).  The manager searches for relevant setter methods that accept that data and also for a `confi
 gure(Map)` method. The setters get what they're asking for (if available) and the `configure()` method accepts the whole combined `Map`. The upshot of this approach is that tools no longer need to conform to any interfaces or patterns. In fact, it's possible to write a FooTool that doesn't know anything about any VelocityTools classes whatsoever and yet be fully instantiable and configurable by VelocityTools. Your tools don't need to know about anything except what they need to know about.
 
 ## Upgrading to 1.4
 

Modified: velocity/site/cms/trunk/content/tools/2.0/view-layoutservlet.mdtext
URL: http://svn.apache.org/viewvc/velocity/site/cms/trunk/content/tools/2.0/view-layoutservlet.mdtext?rev=1744249&r1=1744248&r2=1744249&view=diff
==============================================================================
--- velocity/site/cms/trunk/content/tools/2.0/view-layoutservlet.mdtext (original)
+++ velocity/site/cms/trunk/content/tools/2.0/view-layoutservlet.mdtext Tue May 17 10:44:17 2016
@@ -8,7 +8,7 @@ This is an extension to the basic Veloci
 
 Since this class is an extension of the VelocityViewServlet (VVS), to use it simply change the servlet-class value of the web.xml entry to the following class:
 
-[org.apache.velocity.tools.view.servlet.VelocityLayoutServlet](javadoc/org/apache/velocity/tools/view/servlet/VelocityLayoutServlet.html)
+[org.apache.velocity.tools.view.servlet.VelocityLayoutServlet](apidocs/org/apache/velocity/tools/view/servlet/VelocityLayoutServlet.html)
 
 ## Configuration Settings
 

Modified: velocity/site/cms/trunk/content/tools/2.0/view-servlet.mdtext
URL: http://svn.apache.org/viewvc/velocity/site/cms/trunk/content/tools/2.0/view-servlet.mdtext?rev=1744249&r1=1744248&r2=1744249&view=diff
==============================================================================
--- velocity/site/cms/trunk/content/tools/2.0/view-servlet.mdtext (original)
+++ velocity/site/cms/trunk/content/tools/2.0/view-servlet.mdtext Tue May 17 10:44:17 2016
@@ -2,10 +2,10 @@ Title: Apache Velocity Tools - VelocityV
 
 ## Overview
 
-This page is still unfinished. Much of this needs to be moved or at least copied to a VelocityView page, as it applies to anything using a [VelocityView](javadoc/org/apache/velocity/tools/view/VelocityView.html) instance under the covers (including the [VelocityViewTag](view-tag.html)). [Help is welcome!](index.html#Contribution)
+This page is still unfinished. Much of this needs to be moved or at least copied to a VelocityView page, as it applies to anything using a [VelocityView](apidocs/org/apache/velocity/tools/view/VelocityView.html) instance under the covers (including the [VelocityViewTag](view-tag.html)). [Help is welcome!](index.html#Contribution)
 {.note}
 
-[Javadoc is here](javadoc/org/apache/velocity/tools/view/VelocityViewServlet.html).
+[Javadoc is here](apidocs/org/apache/velocity/tools/view/VelocityViewServlet.html).
 
 A typical application use-case for the VelocityViewServlet is to provide the view rendering layer for a servlet-based web application framework. The [VelocityStruts](struts.html) subproject uses the approach to bring Velocity templates to the Struts 1 application framework.
 
@@ -101,7 +101,7 @@ You may have noticed that toolbox suppor
 
 The scope that you set for your toolbox will determine the lifecycle of the tools within it:
 
-+ *application* scoped tools will be instantiated only once when first used by a template and then reused by all templates for each subsequent request. Due to this, it is *strongly* encouraged that your application scoped tools be completely threadsafe. The [MathTool](javadoc/org/apache/velocity/tools/generic/MathTool.html) (one of the [GenericTools](generic.html)) is a good example of tool meant to be application scoped.
++ *application* scoped tools will be instantiated only once when first used by a template and then reused by all templates for each subsequent request. Due to this, it is *strongly* encouraged that your application scoped tools be completely threadsafe. The [MathTool](apidocs/org/apache/velocity/tools/generic/MathTool.html) (one of the [GenericTools](generic.html)) is a good example of tool meant to be application scoped.
 +  *session* scoped tools are instantiated at most once per unique session (if they are used by a template processed for that session) and are then reused for every request associated with that particular session.
 + *request* is the most common scope. Tools with this scope are instantiated at most once per servlet request fed to that VelocityView (if they are used by a template processed during that request).
 
@@ -112,7 +112,7 @@ You can specify a restriction on the req
     <tool restrictTo="/catalog/*"
       class="com.mycompany.tools.CatalogTool"/>
 
-You may have noticed that this example tool configuration doesn't have a "key" attribute.  This is because VelocityTools 2 honors the [Key]Tool naming convention. So a tool with the simple name of "CatalogTool" will automatically be given the key "catalog" unless another key is specified in the tool configuration or using the [DefaultKey](javadoc/org/apache/velocity/tools/config/DefaultKey.html) annotation on the class.
+You may have noticed that this example tool configuration doesn't have a "key" attribute.  This is because VelocityTools 2 honors the [Key]Tool naming convention. So a tool with the simple name of "CatalogTool" will automatically be given the key "catalog" unless another key is specified in the tool configuration or using the [DefaultKey](apidocs/org/apache/velocity/tools/config/DefaultKey.html) annotation on the class.
 
 #### Tool Properties
 

Modified: velocity/site/cms/trunk/content/tools/2.0/view-tag.mdtext
URL: http://svn.apache.org/viewvc/velocity/site/cms/trunk/content/tools/2.0/view-tag.mdtext?rev=1744249&r1=1744248&r2=1744249&view=diff
==============================================================================
--- velocity/site/cms/trunk/content/tools/2.0/view-tag.mdtext (original)
+++ velocity/site/cms/trunk/content/tools/2.0/view-tag.mdtext Tue May 17 10:44:17 2016
@@ -51,4 +51,4 @@ You can also store the results of any of
     #end
     </velocity:view>
 
-For more details, see the [Javadoc](javadoc/org/apache/velocity/tools/view/jsp/VelocityViewTag.html) or the [TLD](http://svn.apache.org/repos/asf/velocity/tools/trunk/src/main/java/META-INF/velocity-view.tld).
+For more details, see the [Javadoc](apidocs/org/apache/velocity/tools/view/jsp/VelocityViewTag.html) or the [TLD](http://svn.apache.org/repos/asf/velocity/tools/trunk/src/main/java/META-INF/velocity-view.tld).

Modified: velocity/site/cms/trunk/content/tools/2.0/view.mdtext
URL: http://svn.apache.org/viewvc/velocity/site/cms/trunk/content/tools/2.0/view.mdtext?rev=1744249&r1=1744248&r2=1744249&view=diff
==============================================================================
--- velocity/site/cms/trunk/content/tools/2.0/view.mdtext (original)
+++ velocity/site/cms/trunk/content/tools/2.0/view.mdtext Tue May 17 10:44:17 2016
@@ -22,11 +22,11 @@ The dependencies required for VelocityVi
 
 ## VelocityView Object
 
-The [VelocityView](javadoc/org/apache/velocity/tools/view/VelocityView.html) object forms the core of the VelocityView infrastructure.  In particular, it serves as the base class for the following:
+The [VelocityView](apidocs/org/apache/velocity/tools/view/VelocityView.html) object forms the core of the VelocityView infrastructure.  In particular, it serves as the base class for the following:
 
 ### [VelocityViewServlet](view-servlet.html)
 
-The [VelocityViewServlet](javadoc/org/apache/velocity/tools/view/VelocityViewServlet.html) class is a standalone servlet that renders Velocity templates. It can be invoked directly from web client's requests, or via servlet forwarding similar to how JSP files are rendered by JSPServlet.
+The [VelocityViewServlet](apidocs/org/apache/velocity/tools/view/VelocityViewServlet.html) class is a standalone servlet that renders Velocity templates. It can be invoked directly from web client's requests, or via servlet forwarding similar to how JSP files are rendered by JSPServlet.
 
 Detailed documentation is [here](view-servlet.html).
 
@@ -51,14 +51,14 @@ Detailed documentation is [here](view-ta
 
 These are in addition to those provided by [GenericTools](generic.html#Tools):
 
-+ [AbstractSearchTool](javadoc/org/apache/velocity/tools/view/AbstractSearchTool.html) - For doing "searching" and robust pagination of search results. Requires you to create a subclass.
-+ [BrowserTool](javadoc/org/apache/velocity/tools/view/BrowserTool.html) - For identifying the browser and features thereof requesting the template.
-+ [CookieTool](javadoc/org/apache/velocity/tools/view/CookieTool.html) - For convenient cookie access and creation.
-+ [ImportTool](javadoc/org/apache/velocity/tools/view/ImportTool.html) - For pulling down textual content from a URL.
-+ [LinkTool](javadoc/org/apache/velocity/tools/view/LinkTool.html) - For easy building of URLs (both relative or absolute).
-+ [PagerTool](javadoc/org/apache/velocity/tools/view/PagerTool.html) - For doing request-based pagination of items in an arbitrary list.
-+ [ParameterTool](javadoc/org/apache/velocity/tools/view/ParameterTool.html) - For easy retrieval and parsing of ServletRequest parameters.
-+ [ViewContextTool](javadoc/org/apache/velocity/tools/view/ViewContextTool.html) - For convenient access to ViewContext data and meta-data.
++ [AbstractSearchTool](apidocs/org/apache/velocity/tools/view/AbstractSearchTool.html) - For doing "searching" and robust pagination of search results. Requires you to create a subclass.
++ [BrowserTool](apidocs/org/apache/velocity/tools/view/BrowserTool.html) - For identifying the browser and features thereof requesting the template.
++ [CookieTool](apidocs/org/apache/velocity/tools/view/CookieTool.html) - For convenient cookie access and creation.
++ [ImportTool](apidocs/org/apache/velocity/tools/view/ImportTool.html) - For pulling down textual content from a URL.
++ [LinkTool](apidocs/org/apache/velocity/tools/view/LinkTool.html) - For easy building of URLs (both relative or absolute).
++ [PagerTool](apidocs/org/apache/velocity/tools/view/PagerTool.html) - For doing request-based pagination of items in an arbitrary list.
++ [ParameterTool](apidocs/org/apache/velocity/tools/view/ParameterTool.html) - For easy retrieval and parsing of ServletRequest parameters.
++ [ViewContextTool](apidocs/org/apache/velocity/tools/view/ViewContextTool.html) - For convenient access to ViewContext data and meta-data.
 
 ## Examples
 

Modified: velocity/site/cms/trunk/content/tools/devel/config-java.mdtext
URL: http://svn.apache.org/viewvc/velocity/site/cms/trunk/content/tools/devel/config-java.mdtext?rev=1744249&r1=1744248&r2=1744249&view=diff
==============================================================================
--- velocity/site/cms/trunk/content/tools/devel/config-java.mdtext (original)
+++ velocity/site/cms/trunk/content/tools/devel/config-java.mdtext Tue May 17 10:44:17 2016
@@ -22,4 +22,4 @@ As of VelocityTools 2, its no longer mer
     config.data("dataKeys", "list", "version,date,isSimple,foo,bar,dataKeys,switches");
     config.data("switches", "list.boolean", "true,false,false,true");
 
-This example uses the [EasyFactoryConfiguration](javadoc/org/apache/velocity/tools/config/EasyFactoryConfiguration.html) API for brevity, but you can also directly use the [FactoryConfiguration](javadoc/org/apache/velocity/tools/config/FactoryConfiguration.html)/ [ToolboxConfiguration](javadoc/org/apache/velocity/tools/config/ToolboxConfiguration.html)/ [ToolConfiguration](javadoc/org/apache/velocity/tools/config/ToolConfiguration.html)/ [Data](javadoc/org/apache/velocity/tools/config/Data.html) API, as you would probably do if you were to construct your configuration via a dependency injection framework (such as Spring).
+This example uses the [EasyFactoryConfiguration](apidocs/org/apache/velocity/tools/config/EasyFactoryConfiguration.html) API for brevity, but you can also directly use the [FactoryConfiguration](apidocs/org/apache/velocity/tools/config/FactoryConfiguration.html)/ [ToolboxConfiguration](apidocs/org/apache/velocity/tools/config/ToolboxConfiguration.html)/ [ToolConfiguration](apidocs/org/apache/velocity/tools/config/ToolConfiguration.html)/ [Data](apidocs/org/apache/velocity/tools/config/Data.html) API, as you would probably do if you were to construct your configuration via a dependency injection framework (such as Spring).

Modified: velocity/site/cms/trunk/content/tools/devel/configuration.mdtext
URL: http://svn.apache.org/viewvc/velocity/site/cms/trunk/content/tools/devel/configuration.mdtext?rev=1744249&r1=1744248&r2=1744249&view=diff
==============================================================================
--- velocity/site/cms/trunk/content/tools/devel/configuration.mdtext (original)
+++ velocity/site/cms/trunk/content/tools/devel/configuration.mdtext Tue May 17 10:44:17 2016
@@ -8,7 +8,7 @@ The default VelocityTools 2 configuratio
 
 However, it is likely that you will want to add your own data and tools to your VelocityTools 2 configuration or at least want to change the default settings of the standard tools.  To that end, configuration of your applications "toolbox(es)" can be done via XML, Java or properties.  Different configurations can also be easily combined together.
 
-There a few basic concepts to the configuration that it is useful to know.  First, what you are creating a configuration for is a [ToolboxFactory](javadoc/org/apache/velocity/tools/ToolboxFactory.html). This factory produces your toolbox(es) as needed by [VelocityView](view.html) or your own application. A factory can have any number of toolboxes, all distinguished by their scope property. There are three special scopes automatically recognized by VelocityTools 2:  "request", "application", and "session".  The "session" scope is only relevant within a [VelocityView](view.html) app, but the other two may be useful anywhere. Placing a tool within "request" scope means that a new instance will be created for every context.  Placing a tool within "application" scope means that only one instance of the tool will be created and shared throughout the application, effectively acting as a singleton. This, of course, means that thread-safety must be considered when putting a tool in "applicat
 ion" scope.
+There a few basic concepts to the configuration that it is useful to know.  First, what you are creating a configuration for is a [ToolboxFactory](apidocs/org/apache/velocity/tools/ToolboxFactory.html). This factory produces your toolbox(es) as needed by [VelocityView](view.html) or your own application. A factory can have any number of toolboxes, all distinguished by their scope property. There are three special scopes automatically recognized by VelocityTools 2:  "request", "application", and "session".  The "session" scope is only relevant within a [VelocityView](view.html) app, but the other two may be useful anywhere. Placing a tool within "request" scope means that a new instance will be created for every context.  Placing a tool within "application" scope means that only one instance of the tool will be created and shared throughout the application, effectively acting as a singleton. This, of course, means that thread-safety must be considered when putting a tool in "applicat
 ion" scope.
 
 Because of such concerns, Velocity Tools now provides annotations to allow developers to restrict the scope(s) in which a tool can be placed. For more on these and other available annotations, see [Creating Your Own Tools](creating-tools.html).
 

Modified: velocity/site/cms/trunk/content/tools/devel/creating-tools.mdtext
URL: http://svn.apache.org/viewvc/velocity/site/cms/trunk/content/tools/devel/creating-tools.mdtext?rev=1744249&r1=1744248&r2=1744249&view=diff
==============================================================================
--- velocity/site/cms/trunk/content/tools/devel/creating-tools.mdtext (original)
+++ velocity/site/cms/trunk/content/tools/devel/creating-tools.mdtext Tue May 17 10:44:17 2016
@@ -65,9 +65,9 @@ Apart from custom properties you may def
 
 ## Annotations
 
-There are three Annotations provided for tool authors: [DefaultKey](javadoc/org/apache/velocity/tools/config/DefaultKey.html), [InvalidScope](javadoc/org/apache/velocity/tools/config/InvalidScope.html) and [ValidScope](javadoc/org/apache/velocity/tools/config/ValidScope.html).
+There are three Annotations provided for tool authors: [DefaultKey](apidocs/org/apache/velocity/tools/config/DefaultKey.html), [InvalidScope](apidocs/org/apache/velocity/tools/config/InvalidScope.html) and [ValidScope](apidocs/org/apache/velocity/tools/config/ValidScope.html).
 
-As described above, the @DefaultKey annotation is used to specify a default key for your tool.  The @InvalidScope and @ValidScope annotations allow you to restrict the [Scope](javadoc/org/apache/velocity/tools/Scope.html)(s) in which the tool can be used in either negative or positive terms. When described positively using the @ValidScope annotation, the tool may **only** be used in a toolbox with the specified scope. If placed in any other toolbox, an `org.apache.velocity.tools.config.InvalidScopeException` will be thrown.  Using @InvalidScope, on the other hand, allows you reject specific scope(s), whilst implicitly allowing any others.
+As described above, the @DefaultKey annotation is used to specify a default key for your tool.  The @InvalidScope and @ValidScope annotations allow you to restrict the [Scope](apidocs/org/apache/velocity/tools/Scope.html)(s) in which the tool can be used in either negative or positive terms. When described positively using the @ValidScope annotation, the tool may **only** be used in a toolbox with the specified scope. If placed in any other toolbox, an `org.apache.velocity.tools.config.InvalidScopeException` will be thrown.  Using @InvalidScope, on the other hand, allows you reject specific scope(s), whilst implicitly allowing any others.
 
 Here's a scope annotation example:
 
@@ -81,21 +81,21 @@ Here's a scope annotation example:
 
 ### Base Classes
 
-[SafeConfig](javadoc/org/apache/velocity/tools/generic/SafeConfig.html) - This serves as a base class for tools who need to have their configuration be read-only for thread-safety or other reasons.  By default, tools which extend this can only be configured once.
+[SafeConfig](apidocs/org/apache/velocity/tools/generic/SafeConfig.html) - This serves as a base class for tools who need to have their configuration be read-only for thread-safety or other reasons.  By default, tools which extend this can only be configured once.
 
-[LocaleConfig](javadoc/org/apache/velocity/tools/generic/LocaleConfig.html) - Subclass of SafeConfig that has standardized support for configuring a Locale for the tool to use as its default.
+[LocaleConfig](apidocs/org/apache/velocity/tools/generic/LocaleConfig.html) - Subclass of SafeConfig that has standardized support for configuring a Locale for the tool to use as its default.
 
-[FormatConfig](javadoc/org/apache/velocity/tools/generic/FormatConfig.html) - Subclass of LocaleConfig that has standardized support for providing a format string value for the tool to use as its default.
+[FormatConfig](apidocs/org/apache/velocity/tools/generic/FormatConfig.html) - Subclass of LocaleConfig that has standardized support for providing a format string value for the tool to use as its default.
 
 ### Utility Classes
 
-[ClassUtils](javadoc/org/apache/velocity/tools/ClassUtils.html) - Provides utility methods for loading classes, finding methods, accessing static field values, and more.
+[ClassUtils](apidocs/org/apache/velocity/tools/ClassUtils.html) - Provides utility methods for loading classes, finding methods, accessing static field values, and more.
 
-[ConversionUtils](javadoc/org/apache/velocity/tools/ConversionUtils.html) - Provides utility methods for common type conversions/value parsing.
+[ConversionUtils](apidocs/org/apache/velocity/tools/ConversionUtils.html) - Provides utility methods for common type conversions/value parsing.
 
-[ServletUtils](javadoc/org/apache/velocity/tools/view/ServletUtils.html) - Utility methods for the servlet environment, mostly centered on accessing the VelocityView or tool instances handled thereby.
+[ServletUtils](apidocs/org/apache/velocity/tools/view/ServletUtils.html) - Utility methods for the servlet environment, mostly centered on accessing the VelocityView or tool instances handled thereby.
 
-[ValueParser] (javadoc/org/apache/velocity/tools/generic/ValueParser.html) - Used to retrieve and parse (aka convert) String values pulled from a map; this is mostly commonly used directly by other tools rather than within templates.
+[ValueParser] (apidocs/org/apache/velocity/tools/generic/ValueParser.html) - Used to retrieve and parse (aka convert) String values pulled from a map; this is mostly commonly used directly by other tools rather than within templates.
 
 ## Designing Template-Friendly Interfaces
 
@@ -114,7 +114,7 @@ Always return null on errors! No Excepti
 
 This, of course, assumes that quiet notation is not being used for that reference.  For this reason, it may be prudent to give your tool access to a logging facility in order to log exceptions and make sure important errors are not silently swallowed. Standard tool management for VelocityTools (even just GenericTools) makes the result of `velocityEngine.getLog()` available to tools as a property under the key "log".  So log access can be added as simply as adding a `public void setLog(org.slf4j.Logger log)` method and utilizing the provided Log instance.
 
-If you wish to toggle the exception catching or, more importantly, if you prefer to catch exceptions globally with a Velocity Event Handler, then have your tool watch for the "catchExceptions" property.  This is `false` by default, but if the VelocityEngine has a MethodExceptionEventHandler configured, then it will be automatically set to `true`.  Again, just add a `public void setCatchExceptions(boolean catch)` method to your tool or watch for the "catchExceptions" property in your `public void configure(Map props)` method.  See [RenderTool](javadoc/org/apache/velocity/tools/generic/RenderTool.html) for an example of this.
+If you wish to toggle the exception catching or, more importantly, if you prefer to catch exceptions globally with a Velocity Event Handler, then have your tool watch for the "catchExceptions" property.  This is `false` by default, but if the VelocityEngine has a MethodExceptionEventHandler configured, then it will be automatically set to `true`.  Again, just add a `public void setCatchExceptions(boolean catch)` method to your tool or watch for the "catchExceptions" property in your `public void configure(Map props)` method.  See [RenderTool](apidocs/org/apache/velocity/tools/generic/RenderTool.html) for an example of this.
 
 ### Be Flexible
 
@@ -124,13 +124,13 @@ Of course, there may be times when you w
 
 ### Be Careful
 
-The first thing to remember is that all public methods declared in public classes may be called from templates.  If it is imperative that a method not be called from a template, you must either change its permissions, its class's permissions or else put some sort of guard into the implementation of the method that renders it harmless when used by a template.  See the implementation of `configure(Map)` in [SafeConfig](javadoc/org/apache/velocity/tools/generic/SafeConfig.html) for an example of the latter option.
+The first thing to remember is that all public methods declared in public classes may be called from templates.  If it is imperative that a method not be called from a template, you must either change its permissions, its class's permissions or else put some sort of guard into the implementation of the method that renders it harmless when used by a template.  See the implementation of `configure(Map)` in [SafeConfig](apidocs/org/apache/velocity/tools/generic/SafeConfig.html) for an example of the latter option.
 
 The second thing to think about is thread-safety. If your tool maintains internal state that is in any way changed by the calling of its public methods, then your tool is not thread safe.  The only thread-safe tools are those that maintain no state or are otherwise immutable (e.g. return new, copied instances w/changed state and leave original unchanged). If your tool is not thread-safe, you should seriously consider [using a scope-limiting annotation](#Annotations) to prevent such problems.
 
 Thread-safety is, of course, most important if your tool is meant to be used in "application" or "session" scoped toolboxes for web applications or any other multi-threaded application.  Allowing access to non-thread-safe tools in those scopes can lead to all sorts of unpleasant problems. Please note that sometimes request scope isn't safe either! if you #parse subtemplates or are otherwise composing your page of separate pieces (e.g. Tiles) that may not know what each other are doing at any one time.
 
-[SafeConfig](javadoc/org/apache/velocity/tools/generic/SafeConfig.html) and its subclasses can help you have safely configurable tools in any scope.  They do this by only allowing the public `configure(Map)` method to be called once.  All other configuration methods should then be declared protected and the tool cannot be re-configured by a template.  This technique may, in the future, be changed to allow you to replace the configure(Map) method with a constructor that takes a Map of configuration properties, but for various reasons, this is not currently the case.
+[SafeConfig](apidocs/org/apache/velocity/tools/generic/SafeConfig.html) and its subclasses can help you have safely configurable tools in any scope.  They do this by only allowing the public `configure(Map)` method to be called once.  All other configuration methods should then be declared protected and the tool cannot be re-configured by a template.  This technique may, in the future, be changed to allow you to replace the configure(Map) method with a constructor that takes a Map of configuration properties, but for various reasons, this is not currently the case.
 
 As a final note here, if you really have good reason to use a mutable, non-thread-safe application or session scoped tool, tool path restrictions can help you limit possible damage here.  Of course, this is something done purely at the <a href="configuration.html">configuration</a> level and cannot be currently defined by the tool itself.
 
@@ -144,9 +144,9 @@ Another handy technique available to too
 
 In VelocityTools' standard set of tools, this practice is put into place often and in a few different ways. Here's a few examples, out of the many tools which make good use of fluent interfaces and a `get(key)` method.
 
-+ [ResourceTool](javadoc/org/apache/velocity/tools/generic/ResourceTool.html) uses subtools to allow you to type `$text.org.com.Foo` instead of `$text.get('org.com.Foo')` or worse, something very java-ish like `$text.getResourceFromBundle('messages.properties', 'org.com.Foo')`. This is achieved by having the get() method return a new instance of its `Key` subclass that carries with it the value to be gotten. The Key, in turn, has a get() method that does the same (and more), returning a new Key instance that carries the concatenated values of both get() calls.  And so on it goes, until the final resulting value is rendered by Velocity calling the last Key's toString() method.
-+ [LinkTool](javadoc/org/apache/velocity/tools/view/LinkTool.html) takes a different approach.  Rather than use a subclass as the subtool, it uses itself.  Almost every method in LinkTool returns a copy of the original instance with the addition of the latest value.  Both this approach and that of ResourceTool provide great flexibility to the template author.  They can use the tools however they wish, with no concerns about thread collisions, shared state or lifecycle. And with modern JVMs, the performance cost of this flexibility is minimal--light object creation and reflection have become cheap and fast, and short-lived instances like those created in the process are quickly garbage collected.
-+ [ClassTool](javadoc/org/apache/velocity/tools/generic/ClassTool.html) uses subtools to a somewhat different end.  Rather than simply replicating the interface of the parent, the subtools provide a natural interface wrapping around the result of the previous call.  This is done because the reflection API provided by JavaSE is not at all template-friendly.  ClassTool wraps almost all returned methods, contructors and fields with subtools that continue to provide a natural, template-friendly interface.
-+ [AlternatorTool](javadoc/org/apache/velocity/tools/generic/AlternatorTool.html) falls into a very simple class of "subtool" uses.  In this case, the AlternatorTool class serves only as a factory for creating instances of the separate Alternator class.  In this case, the so-called "subtool" is really the main thing and the tool exists solely to provide access to it.
-+ [LoopTool](javadoc/org/apache/velocity/tools/generic/LoopTool.html) might be the strangest of them all.  It is unlikely that you would find need to create such a tool, but if you are curious, read on. LoopTool exists to add value and convenience to using the #foreach directive.  The methods on the main class are either used when starting a #foreach loop or else for use during said loop. The starting ones return a "subtool" of sorts called [ManagedIterator](javadoc/org/apache/velocity/tools/generic/LoopTool.ManagedIterator.html), which provides a few fluent methods for refinement of the loop control. The final result of those, however, is largely just used by #foreach internally. While the loop is going, however, the original LoopTool itself may be directly used to observe and/or influence the ManagedIterator being used internally by #foreach. This is because the main LoopTool keeps track of all its subtool instances in a Stack.  This is very different from most subtool situations,
  where the tool and subtool are immediately disassociated.
++ [ResourceTool](apidocs/org/apache/velocity/tools/generic/ResourceTool.html) uses subtools to allow you to type `$text.org.com.Foo` instead of `$text.get('org.com.Foo')` or worse, something very java-ish like `$text.getResourceFromBundle('messages.properties', 'org.com.Foo')`. This is achieved by having the get() method return a new instance of its `Key` subclass that carries with it the value to be gotten. The Key, in turn, has a get() method that does the same (and more), returning a new Key instance that carries the concatenated values of both get() calls.  And so on it goes, until the final resulting value is rendered by Velocity calling the last Key's toString() method.
++ [LinkTool](apidocs/org/apache/velocity/tools/view/LinkTool.html) takes a different approach.  Rather than use a subclass as the subtool, it uses itself.  Almost every method in LinkTool returns a copy of the original instance with the addition of the latest value.  Both this approach and that of ResourceTool provide great flexibility to the template author.  They can use the tools however they wish, with no concerns about thread collisions, shared state or lifecycle. And with modern JVMs, the performance cost of this flexibility is minimal--light object creation and reflection have become cheap and fast, and short-lived instances like those created in the process are quickly garbage collected.
++ [ClassTool](apidocs/org/apache/velocity/tools/generic/ClassTool.html) uses subtools to a somewhat different end.  Rather than simply replicating the interface of the parent, the subtools provide a natural interface wrapping around the result of the previous call.  This is done because the reflection API provided by JavaSE is not at all template-friendly.  ClassTool wraps almost all returned methods, contructors and fields with subtools that continue to provide a natural, template-friendly interface.
++ [AlternatorTool](apidocs/org/apache/velocity/tools/generic/AlternatorTool.html) falls into a very simple class of "subtool" uses.  In this case, the AlternatorTool class serves only as a factory for creating instances of the separate Alternator class.  In this case, the so-called "subtool" is really the main thing and the tool exists solely to provide access to it.
++ [LoopTool](apidocs/org/apache/velocity/tools/generic/LoopTool.html) might be the strangest of them all.  It is unlikely that you would find need to create such a tool, but if you are curious, read on. LoopTool exists to add value and convenience to using the #foreach directive.  The methods on the main class are either used when starting a #foreach loop or else for use during said loop. The starting ones return a "subtool" of sorts called [ManagedIterator](apidocs/org/apache/velocity/tools/generic/LoopTool.ManagedIterator.html), which provides a few fluent methods for refinement of the loop control. The final result of those, however, is largely just used by #foreach internally. While the loop is going, however, the original LoopTool itself may be directly used to observe and/or influence the ManagedIterator being used internally by #foreach. This is because the main LoopTool keeps track of all its subtool instances in a Stack.  This is very different from most subtool situations,
  where the tool and subtool are immediately disassociated.
 

Modified: velocity/site/cms/trunk/content/tools/devel/dependencies.mdtext
URL: http://svn.apache.org/viewvc/velocity/site/cms/trunk/content/tools/devel/dependencies.mdtext?rev=1744249&r1=1744248&r2=1744249&view=diff
==============================================================================
--- velocity/site/cms/trunk/content/tools/devel/dependencies.mdtext (original)
+++ velocity/site/cms/trunk/content/tools/devel/dependencies.mdtext Tue May 17 10:44:17 2016
@@ -11,40 +11,40 @@ Note: Java version 1.5+ is required for
 
 Jar Name | Version | Compile | Runtime | Notes
 ---------|---------|---------|---------|------
-commons-beanutils | 1.7.0 | Yes | Yes | Required for core infrastructure, [MathTool](javadoc/org/apache/velocity/tools/generic/MathTool.html) and [SortTool](javadoc/org/apache/velocity/tools/generic/SortTool.html)
+commons-beanutils | 1.7.0 | Yes | Yes | Required for core infrastructure, [MathTool](apidocs/org/apache/velocity/tools/generic/MathTool.html) and [SortTool](apidocs/org/apache/velocity/tools/generic/SortTool.html)
 commons-digester | 1.8 | Yes | Yes | Required for [xml configuration](config-xml.html)
 slf4j-api | 1.7.2+ | Yes | Yes | Required for Velocity Engine and Velocity Tools
 jcl-over-slf4j | 1.7.12 | Yes | Yes | Required for Digester
-dom4j | 1.1+ | Yes | No |   Required only for [XmlTool](javadoc/org/apache/velocity/tools/generic/XmlTool.html)
-velocity | 2.0+ | Yes | Yes | Required for core infrastructure, [ClassTool](javadoc/org/apache/velocity/tools/generic/ClassTool.html), [LinkTool](javadoc/org/apache/velocity/tools/generic/LinkTool.html), [LoopTool](javadoc/org/apache/velocity/tools/generic/LoopTool.html), [RenderTool](javadoc/org/apache/velocity/tools/generic/RenderTool.html) and [XmlTool](javadoc/org/apache/velocity/tools/generic/XmlTool.html)
+dom4j | 1.1+ | Yes | No |   Required only for [XmlTool](apidocs/org/apache/velocity/tools/generic/XmlTool.html)
+velocity | 2.0+ | Yes | Yes | Required for core infrastructure, [ClassTool](apidocs/org/apache/velocity/tools/generic/ClassTool.html), [LinkTool](apidocs/org/apache/velocity/tools/generic/LinkTool.html), [LoopTool](apidocs/org/apache/velocity/tools/generic/LoopTool.html), [RenderTool](apidocs/org/apache/velocity/tools/generic/RenderTool.html) and [XmlTool](apidocs/org/apache/velocity/tools/generic/XmlTool.html)
 
 ### VelocityView
 
 Jar Name | Version | Compile | Runtime | Notes
 ---------|---------|---------|---------|------
-commons-beanutils | 1.7.0 | Yes | Yes | Required for core infrastructure, [MathTool](javadoc/org/apache/velocity/tools/generic/MathTool.html) and [SortTool](javadoc/org/apache/velocity/tools/generic/SortTool.html)
+commons-beanutils | 1.7.0 | Yes | Yes | Required for core infrastructure, [MathTool](apidocs/org/apache/velocity/tools/generic/MathTool.html) and [SortTool](apidocs/org/apache/velocity/tools/generic/SortTool.html)
 commons-digester | 1.8 | Yes | Yes | Required for [xml configuration](config-xml.html)
 slf4j-api | 1.7.2+ | Yes | Yes | Required for Velocity Engine and Velocity Tools
 jcl-over-slf4j | 1.7.12 | Yes | Yes | Required for Digester
-dom4j | 1.1+ | Yes | No |   Required only for [XmlTool](javadoc/org/apache/velocity/tools/generic/XmlTool.html)
-servletapi | 2.3+ | Yes | Yes | Required for all [VelocityView](javadoc/org/apache/velocity/tools/view/package-summary.html) tools except for [RenderTool](javadoc/org/apache/velocity/tools/generic/RenderTool.html)
-velocity | 2.0+ | Yes | Yes | Required for core infrastructure, [ClassTool](javadoc/org/apache/velocity/tools/generic/ClassTool.html), [RenderTool](javadoc/org/apache/velocity/tools/generic/RenderTool.html), [XmlTool](javadoc/org/apache/velocity/tools/generic/XmlTool.html), [AbstractSearchTool](javadoc/org/apache/velocity/tools/view/AbstractSearchTool.html), [ContextTool](javadoc/org/apache/velocity/tools/view/ContextTool.html), [LinkTool](javadoc/org/apache/velocity/tools/view/LinkTool.html), [LoopTool](javadoc/org/apache/velocity/tools/view/LoopTool.html) and [MultiViewsTool](javadoc/org/apache/velocity/tools/view/MultiViewsTool.html)
+dom4j | 1.1+ | Yes | No |   Required only for [XmlTool](apidocs/org/apache/velocity/tools/generic/XmlTool.html)
+servletapi | 2.3+ | Yes | Yes | Required for all [VelocityView](apidocs/org/apache/velocity/tools/view/package-summary.html) tools except for [RenderTool](apidocs/org/apache/velocity/tools/generic/RenderTool.html)
+velocity | 2.0+ | Yes | Yes | Required for core infrastructure, [ClassTool](apidocs/org/apache/velocity/tools/generic/ClassTool.html), [LoopTool](apidocs/org/apache/velocity/tools/generic/LoopTool.html), [RenderTool](apidocs/org/apache/velocity/tools/generic/RenderTool.html), [XmlTool](apidocs/org/apache/velocity/tools/generic/XmlTool.html), [AbstractSearchTool](apidocs/org/apache/velocity/tools/view/AbstractSearchTool.html), [ContextTool](apidocs/org/apache/velocity/tools/view/ContextTool.html) and [LinkTool](apidocs/org/apache/velocity/tools/view/LinkTool.html)
 
 ### VelocityStruts
 
 Jar Name | Version | Compile | Runtime | Notes
 ---------|---------|---------|---------|------
-commons-beanutils | 1.7.0 | Yes | Yes | Required for core infrastructure, [MathTool](javadoc/org/apache/velocity/tools/generic/MathTool.html) and [SortTool](javadoc/org/apache/velocity/tools/generic/SortTool.html)
+commons-beanutils | 1.7.0 | Yes | Yes | Required for core infrastructure, [MathTool](apidocs/org/apache/velocity/tools/generic/MathTool.html) and [SortTool](apidocs/org/apache/velocity/tools/generic/SortTool.html)
 commons-chain | 1.1 | No | Yes | Struts 1.3+ requires this.
 commons-digester | 1.8 | Yes | Yes | Required for [xml configuration](config-xml.html)
 slf4j-api | 1.7.2+ | Yes | Yes | Required for Velocity Engine and Velocity Tools
 jcl-over-slf4j | 1.7.12 | Yes | Yes | Required for Struts and Digester
-dom4j | 1.1+ | Yes | No |   Required only for [XmlTool](javadoc/org/apache/velocity/tools/generic/XmlTool.html)
-struts-core | 1.3.8 | Yes | Yes | Required for all [VelocityStruts](javadoc/org/apache/velocity/tools/struts/package-summary.html) tools
-struts-taglib | 1.3.8 | Yes | Yes | Required for [FormTool](javadoc/org/apache/velocity/tools/struts/FormTool.html), [SecureLinkTool](javadoc/org/apache/velocity/tools/struts/SecureLinkTool.html) and [StrutsLinkTool](javadoc/org/apache/velocity/tools/struts/StrutsLinkTool.html)
-struts-tiles | 1.3.8 | Yes | Yes | Required for [TilesTool](javadoc/org/apache/velocity/tools/struts/TilesTool.html)
-ssl-ext | 1.2 | Yes | No | Required for [SecureLinkTool](javadoc/org/apache/velocity/tools/struts/SecureLinkTool.html)
-commons-validator | 1.3.1 | Yes | Yes | Required for [ValidatorTool](javadoc/org/apache/velocity/tools/struts/ValidatorTool.html)
-servletapi | 2.3+ | Yes | Yes | Required for all [VelocityStruts](javadoc/org/apache/velocity/tools/struts/package-summary.html) tools and all [VelocityView](javadoc/org/apache/velocity/tools/view/package-summary.html) tools except for [RenderTool](javadoc/org/apache/velocity/tools/generic/RenderTool.html)
-velocity | 2.0+ | Yes | Yes | Required for core infrastructure, [ClassTool](javadoc/org/apache/velocity/tools/generic/ClassTool.html), [RenderTool](javadoc/org/apache/velocity/tools/generic/RenderTool.html), [XmlTool](javadoc/org/apache/velocity/tools/generic/XmlTool.html), [AbstractSearchTool](javadoc/org/apache/velocity/tools/view/AbstractSearchTool.html), [ContextTool](javadoc/org/apache/velocity/tools/view/ContextTool.html), [LinkTool](javadoc/org/apache/velocity/tools/view/LinkTool.html), [LoopTool](javadoc/org/apache/velocity/tools/view/LoopTool.html), [MultiViewsTool](javadoc/org/apache/velocity/tools/view/MultiViewsTool.html), [SecureLinkTool](javadoc/org/apache/velocity/tools/struts/SecureLinkTool.html), [StrutsLinkTool](javadoc/org/apache/velocity/tools/struts/StrutsLinkTool.html), [TilesTool](javadoc/org/apache/velocity/tools/struts/TilesTool.html) and [MessageTool](javadoc/org/apache/velocity/tools/struts/MessageTool.html)
+dom4j | 1.1+ | Yes | No |   Required only for [XmlTool](apidocs/org/apache/velocity/tools/generic/XmlTool.html)
+struts-core | 1.3.8 | Yes | Yes | Required for all [VelocityStruts](apidocs/org/apache/velocity/tools/struts/package-summary.html) tools
+struts-taglib | 1.3.8 | Yes | Yes | Required for [FormTool](apidocs/org/apache/velocity/tools/struts/FormTool.html), [SecureLinkTool](apidocs/org/apache/velocity/tools/struts/SecureLinkTool.html) and [StrutsLinkTool](apidocs/org/apache/velocity/tools/struts/StrutsLinkTool.html)
+struts-tiles | 1.3.8 | Yes | Yes | Required for [TilesTool](apidocs/org/apache/velocity/tools/struts/TilesTool.html)
+ssl-ext | 1.2 | Yes | No | Required for [SecureLinkTool](apidocs/org/apache/velocity/tools/struts/SecureLinkTool.html)
+commons-validator | 1.3.1 | Yes | Yes | Required for [ValidatorTool](apidocs/org/apache/velocity/tools/struts/ValidatorTool.html)
+servletapi | 2.3+ | Yes | Yes | Required for all [VelocityStruts](apidocs/org/apache/velocity/tools/struts/package-summary.html) tools and all [VelocityView](apidocs/org/apache/velocity/tools/view/package-summary.html) tools except for [RenderTool](apidocs/org/apache/velocity/tools/generic/RenderTool.html)
+velocity | 2.0+ | Yes | Yes | Required for core infrastructure, [ClassTool](apidocs/org/apache/velocity/tools/generic/ClassTool.html), [RenderTool](apidocs/org/apache/velocity/tools/generic/RenderTool.html), [XmlTool](apidocs/org/apache/velocity/tools/generic/XmlTool.html), [AbstractSearchTool](apidocs/org/apache/velocity/tools/view/AbstractSearchTool.html), [ContextTool](apidocs/org/apache/velocity/tools/view/ContextTool.html), [LinkTool](apidocs/org/apache/velocity/tools/view/LinkTool.html), [LoopTool](apidocs/org/apache/velocity/tools/view/LoopTool.html), [MultiViewsTool](apidocs/org/apache/velocity/tools/view/MultiViewsTool.html), [SecureLinkTool](apidocs/org/apache/velocity/tools/struts/SecureLinkTool.html), [StrutsLinkTool](apidocs/org/apache/velocity/tools/struts/StrutsLinkTool.html), [TilesTool](apidocs/org/apache/velocity/tools/struts/TilesTool.html) and [MessageTool](apidocs/org/apache/velocity/tools/struts/MessageTool.html)
 

Modified: velocity/site/cms/trunk/content/tools/devel/frameworks.mdtext
URL: http://svn.apache.org/viewvc/velocity/site/cms/trunk/content/tools/devel/frameworks.mdtext?rev=1744249&r1=1744248&r2=1744249&view=diff
==============================================================================
--- velocity/site/cms/trunk/content/tools/devel/frameworks.mdtext (original)
+++ velocity/site/cms/trunk/content/tools/devel/frameworks.mdtext Tue May 17 10:44:17 2016
@@ -12,7 +12,7 @@ VelocityTools is not meant to be a frame
 
 ### Configuring
 
-[VelocityView](javadoc/org/apache/velocity/tools/view/VelocityView.html) supports the following configuration parameters as <init-param>s in web.xml:
+[VelocityView](apidocs/org/apache/velocity/tools/view/VelocityView.html) supports the following configuration parameters as <init-param>s in web.xml:
 
 org.apache.velocity.toolbox
 : Path and name of the toolbox configuration file. The path must be relative to the web application root directory. If this parameter is not found, the servlet will check for a toolbox file at `/WEB-INF/tools.xml`.