diff -r 8c85ab4cf3aa -r 242510015401 server/java/renkan-web/src/main/webapp/static/js/thymol.js
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/server/java/renkan-web/src/main/webapp/static/js/thymol.js	Mon Jul 21 14:48:01 2014 +0200
@@ -0,0 +1,376 @@
+/*-------------------- Thymol - the flavour of Thymeleaf --------------------*
+
+   Thymol version 0.1.2 Copyright 2012 James J. Benson.
+   jjbenson .AT. users.sf.net
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" basis,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either expressed or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+ *---------------------------------------------------------------------------*/
+
+var thURL = "http://www.thymeleaf.org";
+var thPrefix = "th";
+var thProtocol = "file:///";
+var thCache = new Object;
+
+$(function() {
+	thymol();
+});
+
+var thymol = function() {
+	
+	var urlParams = {};
+	(function() {
+		var e, a = /\+/g, r = /([^&=]+)=?([^&]*)/g, d = function(s) {
+			return decodeURIComponent(s.replace(a, " "));
+		}, f = function(s) {
+			return new Param(d(s));
+		}, q = window.location.search.substring(1);
+		while (e = r.exec(q)) {
+			urlParams[d(e[1])] = f(e[2]);
+		}
+	})();
+
+	var debug = getThParam("thDebug",true,false);
+	var root = getThParam("thRoot",false,true);
+	var path = getThParam("thPath",false,true);
+
+	$.ajaxSetup({
+		async : false,
+		isLocal : true
+	});
+
+	(function() {
+		var htmlTag = $("html")[0];
+		$(htmlTag.attributes).each(function() {
+			if (thURL == this.value) {
+				var nsspec = this.localName.split(":");
+				if (nsspec.length > 0) {
+					thPrefix = nsspec[nsspec.length - 1];
+					return;
+				}
+			}
+		});
+	})();
+
+	var thIncl = new ThObj("include");
+	var thSubs = new ThObj("substituteby");
+	var thIf = new ThObj("if");
+	var thUnless = new ThObj("unless");
+	var thSwitch = new ThObj("switch");
+	var thCase = new ThObj("case");
+
+	var thFragEscp = "[" + thPrefix + "\\:fragment='";
+	var base = new ThNode(document, false, null, null, null, document.nodeName, "::", false, document);
+	process(base);
+	return;
+
+	function process(base) {
+		var n = base;
+		while (n.thDoc) {
+			getChildren(n);
+			if (n.firstChild && n.firstChild.thDoc && !n.visited) {
+				n.visited = true;
+				n = n.firstChild;
+			}
+			else {
+				doReplace(n.isNode, n.element, n.thDoc);
+				if (n.nextSibling && n.nextSibling.thDoc) {
+					n = n.nextSibling;
+				}
+				else {
+					if (n == base)
+						break;
+					else {
+						n = n.parentDoc;
+					}
+				}
+			}
+		}
+	}
+
+	function getChildren(base) {
+		var thIfSpecs = $(thIf.escp, base.thDoc);
+		var thUnlessSpecs = $(thUnless.escp, base.thDoc);
+		var thSwitchSpecs = $(thSwitch.escp, base.thDoc);
+		var ths = $(thIfSpecs).add(thUnlessSpecs).add(thSwitchSpecs);
+		ths.each(function() {
+			var element = this;
+			$(element.attributes).each(function() {
+				var thAttr = this;
+				if (thIf.name == thAttr.name || thUnless.name == thAttr.name || thSwitch.name == thAttr.name) {
+					processConditional(element, base, thAttr);
+				}
+			});
+		});
+		var thInclSpecs = $(thIncl.escp, base.thDoc);
+		var thSubsSpecs = $(thSubs.escp, base.thDoc);
+		ths = $(thInclSpecs).add(thSubsSpecs);
+		var count = 0;
+		var last = null;
+		ths.each(function() {
+			var element = this;
+			$(element.attributes).each(function() {
+				var thAttr = this;
+				if (thIncl.name == thAttr.name || thSubs.name == thAttr.name) {
+					var child = processImport(element, base, thAttr);
+					if( child != null ) {
+						if (count == 0) {
+							base.firstChild = child;
+						}
+						else {
+							last.nextSibling = child;
+						}
+						last = child;
+						count++;						
+					}
+				}
+			});
+		});
+	}
+
+	function processConditional(element, base, attr) {
+		var args = attr.value.match(/[$\*#]{(!?.*)}/);
+		var processed = false;
+		if (args.length > 0) {
+			var param = args[1];
+			if (thSwitch.name == attr.name) {
+				processed = processSwitch(element, base, attr, param);
+			}
+			else {
+				var negate = false;
+				if (args[1].charAt(0) == '!') {
+					negate = true;
+					param = args[1].substring(1);
+				}
+				if ((!negate && isTrue(param)) || (negate && !isTrue(param))) {
+					if (thUnless.name == attr.name) { // true for "if" and
+						// false for "unless"
+						element.innerHTML = "";
+					}
+					processed = true;
+				}
+				else {
+					if (thIf.name == attr.name) { // false for "if", true for
+						// "unless"
+						element.innerHTML = "";
+					}
+					processed = true;
+				}
+
+			}
+		}
+		if (!processed && debug) {
+			window.alert("thymol.processConditional cannot process: " + attr.name + "=\"" + attr.value + "\"\n" + element.innerHTML);
+		}
+		element.removeAttribute(attr.name);
+	}
+
+	function processSwitch(element, base, attr, param) {
+		var matched = false;
+		var haveDefault = false;
+		var thCaseSpecs = $(thCase.escp, element);
+		thCaseSpecs.each(function() {
+			var caseClause = this;
+			var remove = true;
+			$(caseClause.attributes).each(function() {
+				var ccAttr = this;
+				if (thCase.name == ccAttr.name) {
+					if (!matched) {
+						var s = urlParams[param];
+						if (ccAttr.value == "*" || (s && (s.getStringValue() == ccAttr.value))) {
+							matched = true;
+							remove = false;
+						}
+					}
+					caseClause.removeAttribute(ccAttr.name);
+				}
+			});
+			if (remove) {
+				caseClause.innerHTML = "";
+			}
+		});
+		return matched;
+	}
+
+	function processImport(element, base, attr) {
+		var importNode = null;
+		var filePart = null;
+		var fragmentPart = "::";
+		if (attr.value.indexOf("::") < 0) {
+			filePart = getFilePart(attr.value); 
+		}
+		else {
+			var names = attr.value.split("::");
+			filePart = getFilePart(names[0].trim());
+			fragmentPart = substitute(names[1].trim());
+		}
+		var isNode = (thSubs.name == attr.localName);
+		if (thCache[filePart] != null && thCache[filePart][fragmentPart] != null) {
+			isNode = ((thSubs.name == attr.localName) || (fragmentPart == "::"));
+			importNode = new ThNode(thCache[filePart][fragmentPart], false, base, null, null, filePart, fragmentPart, isNode, element);
+		}
+		else {
+			var fileName = filePart + ".html";
+			$.get(fileName, function(content, status) {
+				if ("success" == status) {
+					if (thCache[filePart] == null) {
+						thCache[filePart] = new Object;
+					}
+					if (fragmentPart == "::") {
+						var htmlContent = $("html", content)[0];
+						thCache[filePart][fragmentPart] = htmlContent;
+					}
+					else {
+						var fragSpec = thFragEscp + fragmentPart + "']";
+						var fragArray = $(fragSpec, content);
+						$(fragArray).each(function() {
+							thCache[filePart][fragmentPart] = this;
+						});
+					}
+					importNode = new ThNode(thCache[filePart][fragmentPart], false, base, null, null, filePart, fragmentPart, isNode, element);
+				}
+				else if (debug) {
+					window.alert("file read failed: " + filePart + " fragment: " + fragmentPart);
+				}
+	    	}, "xml");
+			if (importNode == null && debug) {
+				window.alert("fragment import failed: " + filePart + " fragment: " + fragmentPart);
+			}
+		}
+		element.removeAttribute(attr.name);		
+		return importNode;
+	}
+	
+	function getFilePart(part) {
+		var result = substitute(part);
+		if( result.charAt(0) != '.' ) {	// Initial period character indicates a relative path
+			if( result.indexOf('/') >= 0 ) {	// If it doesn't start with a '.', and there are no path separators, it's also treated as relative
+				result = thProtocol + root + path + result;													
+			}
+		}
+		return result;
+	}
+
+	function doReplace(isNode, element, content) {
+		if (isNode) {
+			element.parentNode.replaceChild(content.cloneNode(true), element);
+		}
+		else {			
+			try {
+				element.innerHTML = content.innerHTML;
+			}
+			catch (err) { // Work-around for IE
+				while (element.firstChild != null) {
+					element.removeChild(element.firstChild);
+				}
+				for (i = 0; i < content.childNodes.length; i++) {
+					element.appendChild(content.childNodes[i].cloneNode(true));
+				}
+			}			
+		}
+	}
+
+	function ThNode(thDoc, visited, parentDoc, firstChild, nextSibling, fileName, fragName, isNode, element) {
+		this.thDoc = thDoc;
+		this.visited = visited;
+		this.parentDoc = parentDoc;
+		this.firstChild = firstChild;
+		this.nextSibling = nextSibling;
+		this.fileName = fileName;
+		this.fragName = fragName;
+		this.isNode = isNode;
+		this.element = element;
+	}
+
+	function ThObj(suffix) {
+		this.name = thPrefix + ":" + suffix;
+		this.escp = "[" + thPrefix + "\\:" + suffix + "]";
+	}
+
+	function Param(valueArg) {
+		this.value = valueArg;
+		this.getBooleanValue = function() {
+			return !(this.value == "false" || this.value == "off" || this.value == "no");
+		};
+		this.getStringValue = function() {
+			return this.value;
+		};
+		this.getNumericValue = function() {
+			return Number(this.value);
+		};
+	}
+
+	function isTrue(arg) {
+		var p = urlParams[arg];
+		if (p) {
+			return p.getBooleanValue();
+		}
+		return false;
+	}
+	
+	function substitute(argValue) {
+		var result = argValue;
+		var args = argValue.match(/[$\*#]{(!?.*)}/);
+		if (args != null && args.length > 0) {
+			var param = args[1];
+			if(param) {
+				var paramValue = urlParams[param];
+				if (paramValue) {
+					result = paramValue.value;
+				}					
+			}		
+		}			
+		return result;
+	}
+
+	function getThParam(paramName,isBoolean,isPath) {
+		var localValue;
+		if( isBoolean ) {
+			localValue = false;
+		}
+		else {
+			localValue = "";			
+		}
+		var theParam = urlParams[paramName];
+		if (isBoolean && theParam) {
+			localValue = theParam.getBooleanValue();
+		}
+		else {
+			var paramValue;
+			try {			
+				paramValue = eval(paramName);
+				if( !(typeof paramValue === "undefined") ) {
+					if( paramValue != null ) {
+						if ( isBoolean ) {
+							localValue = (paramValue==true);
+						}								
+						else {
+							localValue = paramValue;							
+						}
+					}
+				}
+			}
+			catch (err) {
+				if (err instanceof ReferenceError) {					
+				}
+				if (err instanceof EvalError) {					
+				}
+			}				
+		}
+		if( !isBoolean && isPath && localValue.length > 0 && localValue.charAt(localValue.length-1) != '/' ) {
+			localValue = localValue + '/';
+		}
+		return localValue;
+	}
+
+};
\ No newline at end of file