olala 0.0.1

data/vendor/assets/aloha/lib/vendor/grid.locale.en.js

@@ -0,0 +1,133 @@
+define('jqgrid-locale-en', ['jquery'], function (jQuery) {
+var $ = jQuery;
+
+;(function($){
+/**
+ * jqGrid English Translation
+ * Tony Tomov tony@trirand.com
+ * http://trirand.com/blog/ 
+ * Dual licensed under the MIT and GPL licenses:
+ * http://www.opensource.org/licenses/mit-license.php
+ * http://www.gnu.org/licenses/gpl.html
+**/
+$.jgrid = {
+	defaults : {
+		recordtext: "View {0} - {1} of {2}",
+		emptyrecords: "No records to view",
+		loadtext: "Loading...",
+		pgtext : "Page {0} of {1}"
+	},
+	search : {
+		caption: "Search...",
+		Find: "Find",
+		Reset: "Reset",
+		odata : ['equal', 'not equal', 'less', 'less or equal','greater','greater or equal', 'begins with','does not begin with','is in','is not in','ends with','does not end with','contains','does not contain'],
+		groupOps: [	{ op: "AND", text: "all" },	{ op: "OR",  text: "any" }	],
+		matchText: " match",
+		rulesText: " rules"
+	},
+	edit : {
+		addCaption: "Add Record",
+		editCaption: "Edit Record",
+		bSubmit: "Submit",
+		bCancel: "Cancel",
+		bClose: "Close",
+		saveData: "Data has been changed! Save changes?",
+		bYes : "Yes",
+		bNo : "No",
+		bExit : "Cancel",
+		msg: {
+			required:"Field is required",
+			number:"Please, enter valid number",
+			minValue:"value must be greater than or equal to ",
+			maxValue:"value must be less than or equal to",
+			email: "is not a valid e-mail",
+			integer: "Please, enter valid integer value",
+			date: "Please, enter valid date value",
+			url: "is not a valid URL. Prefix required ('http://' or 'https://')",
+			nodefined : " is not defined!",
+			novalue : " return value is required!",
+			customarray : "Custom function should return array!",
+			customfcheck : "Custom function should be present in case of custom checking!"
+			
+		}
+	},
+	view : {
+		caption: "View Record",
+		bClose: "Close"
+	},
+	del : {
+		caption: "Delete",
+		msg: "Delete selected record(s)?",
+		bSubmit: "Delete",
+		bCancel: "Cancel"
+	},
+	nav : {
+		edittext: "",
+		edittitle: "Edit selected row",
+		addtext:"",
+		addtitle: "Add new row",
+		deltext: "",
+		deltitle: "Delete selected row",
+		searchtext: "",
+		searchtitle: "Find records",
+		refreshtext: "",
+		refreshtitle: "Reload Grid",
+		alertcap: "Warning",
+		alerttext: "Please, select row",
+		viewtext: "",
+		viewtitle: "View selected row"
+	},
+	col : {
+		caption: "Select columns",
+		bSubmit: "Ok",
+		bCancel: "Cancel"
+	},
+	errors : {
+		errcap : "Error",
+		nourl : "No url is set",
+		norecords: "No records to process",
+		model : "Length of colNames <> colModel!"
+	},
+	formatter : {
+		integer : {thousandsSeparator: " ", defaultValue: '0'},
+		number : {decimalSeparator:".", thousandsSeparator: " ", decimalPlaces: 2, defaultValue: '0.00'},
+		currency : {decimalSeparator:".", thousandsSeparator: " ", decimalPlaces: 2, prefix: "", suffix:"", defaultValue: '0.00'},
+		date : {
+			dayNames:   [
+				"Sun", "Mon", "Tue", "Wed", "Thr", "Fri", "Sat",
+				"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
+			],
+			monthNames: [
+				"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
+				"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
+			],
+			AmPm : ["am","pm","AM","PM"],
+			S: function (j) {return j < 11 || j > 13 ? ['st', 'nd', 'rd', 'th'][Math.min((j - 1) % 10, 3)] : 'th'},
+			srcformat: 'Y-m-d',
+			newformat: 'd/m/Y',
+			masks : {
+				ISO8601Long:"Y-m-d H:i:s",
+				ISO8601Short:"Y-m-d",
+				ShortDate: "n/j/Y",
+				LongDate: "l, F d, Y",
+				FullDateTime: "l, F d, Y g:i:s A",
+				MonthDay: "F d",
+				ShortTime: "g:i A",
+				LongTime: "g:i:s A",
+				SortableDateTime: "Y-m-d\\TH:i:s",
+				UniversalSortableDateTime: "Y-m-d H:i:sO",
+				YearMonth: "F, Y"
+			},
+			reformatAfterEdit : false
+		},
+		baseLinkUrl: '',
+		showAction: '',
+		target: '',
+		checkbox : {disabled:true},
+		idName : 'id'
+	}
+};
+})(jQuery);
+
+}); // define()

data/vendor/assets/aloha/lib/vendor/ierange-m2.js

@@ -0,0 +1,508 @@
+(function (window, undefined) {
+	
+	var jQuery = window.alohaQuery || window.jQuery,
+		$ = jQuery,
+		//		GENTICS = window.GENTICS,
+		//		Aloha = window.Aloha,
+		DOMUtils, TextRangeUtils, selection, DOMRange, RangeIterator, DOMSelection;
+
+	/*
+	 * Only execute the following code if we are in IE (check for
+	 * document.attachEvent, this is a microsoft event and therefore only available
+	 * in IE).
+	 */
+
+	if (document.attachEvent && document.selection) {
+		/*!
+		 *   DOM Ranges for Internet Explorer (m2)
+		 *
+		 *   Copyright (c) 2009 Tim Cameron Ryan
+		 *   Released under the MIT/X License
+		 *   available at http://code.google.com/p/ierange/
+		 */
+
+		/*
+	  Range reference:
+	    http://www.w3.org/TR/DOM-Level-2-Traversal-Range/ranges.html
+	    http://mxr.mozilla.org/mozilla-central/source/content/base/src/nsRange.cpp
+	    https://developer.mozilla.org/En/DOM:Range
+	  Selection reference:
+	    http://trac.webkit.org/browser/trunk/WebCore/page/DOMSelection.cpp
+	  TextRange reference:
+	    http://msdn.microsoft.com/en-us/library/ms535872.aspx
+	  Other links:
+	    http://jorgenhorstink.nl/test/javascript/range/range.js
+	    http://jorgenhorstink.nl/2006/07/05/dom-range-implementation-in-ecmascript-completed/
+	    http://dylanschiemann.com/articles/dom2Range/dom2RangeExamples.html
+	*/
+
+		//[TODO] better exception support
+
+
+		/*
+	  DOM functions
+	 */
+
+		DOMUtils = {
+			findChildPosition: function (node) {
+				for (var i = 0; node = node.previousSibling; i++)
+				continue;
+				return i;
+			},
+			isDataNode: function (node) {
+				return node && node.nodeValue !== null && node.data !== null;
+			},
+			isAncestorOf: function (parent, node) {
+				return !DOMUtils.isDataNode(parent) && (parent.contains(DOMUtils.isDataNode(node) ? node.parentNode : node) || node.parentNode == parent);
+			},
+			isAncestorOrSelf: function (root, node) {
+				return DOMUtils.isAncestorOf(root, node) || root == node;
+			},
+			findClosestAncestor: function (root, node) {
+				if (DOMUtils.isAncestorOf(root, node)) while (node && node.parentNode != root)
+				node = node.parentNode;
+				return node;
+			},
+			getNodeLength: function (node) {
+				return DOMUtils.isDataNode(node) ? node.length : node.childNodes.length;
+			},
+			splitDataNode: function (node, offset) {
+				if (!DOMUtils.isDataNode(node)) return false;
+				var newNode = node.cloneNode(false);
+				node.deleteData(offset, node.length);
+				newNode.deleteData(0, offset);
+				node.parentNode.insertBefore(newNode, node.nextSibling);
+			}
+		};
+
+		/*
+	  Text Range utilities
+	  functions to simplify text range manipulation in ie
+	 */
+
+		TextRangeUtils = {
+			convertToDOMRange: function (textRange, document) {
+				var domRange, adoptBoundary;
+
+				adoptBoundary = function (domRange, textRange, bStart) {
+					// iterate backwards through parent element to find anchor location
+					var cursorNode = document.createElement('a'),
+						cursor = textRange.duplicate(),
+						parent;
+
+					cursor.collapse(bStart);
+					parent = cursor.parentElement();
+					do {
+						parent.insertBefore(cursorNode, cursorNode.previousSibling);
+						cursor.moveToElementText(cursorNode);
+					} while (cursor.compareEndPoints(bStart ? 'StartToStart' : 'StartToEnd', textRange) > 0 && cursorNode.previousSibling);
+
+					// when we exceed or meet the cursor, we've found the node
+					if (cursor.compareEndPoints(bStart ? 'StartToStart' : 'StartToEnd', textRange) == -1 && cursorNode.nextSibling) {
+						// data node
+						cursor.setEndPoint(bStart ? 'EndToStart' : 'EndToEnd', textRange);
+						domRange[bStart ? 'setStart' : 'setEnd'](cursorNode.nextSibling, cursor.text.length);
+					} else {
+						// element
+						domRange[bStart ? 'setStartBefore' : 'setEndBefore'](cursorNode);
+					}
+					cursorNode.parentNode.removeChild(cursorNode);
+				};
+
+				// return a DOM range
+				domRange = new DOMRange(document);
+				adoptBoundary(domRange, textRange, true);
+				adoptBoundary(domRange, textRange, false);
+				return domRange;
+			},
+
+			convertFromDOMRange: function (domRange) {
+				function adoptEndPoint(textRange, domRange, bStart) {
+					// find anchor node and offset
+					var container = domRange[bStart ? 'startContainer' : 'endContainer'],
+						offset = domRange[bStart ? 'startOffset' : 'endOffset'],
+						textOffset = 0,
+						anchorNode = DOMUtils.isDataNode(container) ? container : container.childNodes[offset],
+						anchorParent = DOMUtils.isDataNode(container) ? container.parentNode : container,
+						cursorNode, cursor;
+
+					// visible data nodes need a text offset
+					if (container.nodeType == 3 || container.nodeType == 4) {
+						textOffset = offset;
+					}
+
+					// create a cursor element node to position range (since we can't select text nodes)
+					cursorNode = domRange._document.createElement('a');
+					anchorParent.insertBefore(cursorNode, anchorNode);
+					cursor = domRange._document.body.createTextRange();
+					cursor.moveToElementText(cursorNode);
+					cursorNode.parentNode.removeChild(cursorNode);
+					// move range
+					textRange.setEndPoint(bStart ? 'StartToStart' : 'EndToStart', cursor);
+					textRange[bStart ? 'moveStart' : 'moveEnd']('character', textOffset);
+				}
+
+				// return an IE text range
+				var textRange = domRange._document.body.createTextRange();
+				adoptEndPoint(textRange, domRange, true);
+				adoptEndPoint(textRange, domRange, false);
+				return textRange;
+			}
+		};
+
+		/*
+	  DOM Range
+	 */
+		DOMRange = function (document) {
+			// save document parameter
+			this._document = document;
+
+			// initialize range
+			//[TODO] this should be located at document[0], document[0]
+			this.startContainer = this.endContainer = document.body;
+			this.endOffset = DOMUtils.getNodeLength(document.body);
+		};
+
+		DOMRange.START_TO_START = 0;
+		DOMRange.START_TO_END = 1;
+		DOMRange.END_TO_END = 2;
+		DOMRange.END_TO_START = 3;
+
+		DOMRange.prototype = {
+			// public properties
+			startContainer: null,
+			startOffset: 0,
+			endContainer: null,
+			endOffset: 0,
+			commonAncestorContainer: null,
+			collapsed: false,
+			// private properties
+			_document: null,
+
+			// private methods
+			_refreshProperties: function () {
+				// collapsed attribute
+				this.collapsed = (this.startContainer == this.endContainer && this.startOffset == this.endOffset);
+				// find common ancestor
+				var node = this.startContainer;
+				while (node && node != this.endContainer && !DOMUtils.isAncestorOf(node, this.endContainer))
+				node = node.parentNode;
+				this.commonAncestorContainer = node;
+			},
+
+			// range methods
+			//[TODO] collapse if start is after end, end is before start
+			setStart: function (container, offset) {
+				this.startContainer = container;
+				this.startOffset = offset;
+				this._refreshProperties();
+			},
+			setEnd: function (container, offset) {
+				this.endContainer = container;
+				this.endOffset = offset;
+				this._refreshProperties();
+			},
+			setStartBefore: function (refNode) {
+				// set start to beore this node
+				this.setStart(refNode.parentNode, DOMUtils.findChildPosition(refNode));
+			},
+			setStartAfter: function (refNode) {
+				// select next sibling
+				this.setStart(refNode.parentNode, DOMUtils.findChildPosition(refNode) + 1);
+			},
+			setEndBefore: function (refNode) {
+				// set end to beore this node
+				this.setEnd(refNode.parentNode, DOMUtils.findChildPosition(refNode));
+			},
+			setEndAfter: function (refNode) {
+				// select next sibling
+				this.setEnd(refNode.parentNode, DOMUtils.findChildPosition(refNode) + 1);
+			},
+			selectNode: function (refNode) {
+				this.setStartBefore(refNode);
+				this.setEndAfter(refNode);
+			},
+			selectNodeContents: function (refNode) {
+				this.setStart(refNode, 0);
+				this.setEnd(refNode, DOMUtils.getNodeLength(refNode));
+			},
+			collapse: function (toStart) {
+				if (toStart) this.setEnd(this.startContainer, this.startOffset);
+				else this.setStart(this.endContainer, this.endOffset);
+			},
+
+			// editing methods
+			cloneContents: function () {
+				// clone subtree
+				return (function cloneSubtree(iterator) {
+					for (var node, frag = document.createDocumentFragment(); node = iterator.next();) {
+						node = node.cloneNode(!iterator.hasPartialSubtree());
+						if (iterator.hasPartialSubtree()) node.appendChild(cloneSubtree(iterator.getSubtreeIterator()));
+						frag.appendChild(node);
+					}
+					return frag;
+				})(new RangeIterator(this));
+			},
+			extractContents: function () {
+				// cache range and move anchor points
+				var range = this.cloneRange();
+				if (this.startContainer != this.commonAncestorContainer) this.setStartAfter(DOMUtils.findClosestAncestor(this.commonAncestorContainer, this.startContainer));
+				this.collapse(true);
+				// extract range
+				return (function extractSubtree(iterator) {
+					for (var node, frag = document.createDocumentFragment(); node = iterator.next();) {
+						if (iterator.hasPartialSubtree()) {
+							node = node.cloneNode(false);
+						} else {
+							iterator.remove();
+						}
+						if (iterator.hasPartialSubtree()) node.appendChild(extractSubtree(iterator.getSubtreeIterator()));
+						frag.appendChild(node);
+					}
+					return frag;
+				})(new RangeIterator(range));
+			},
+			deleteContents: function () {
+				// cache range and move anchor points
+				var range = this.cloneRange();
+				if (this.startContainer != this.commonAncestorContainer) this.setStartAfter(DOMUtils.findClosestAncestor(this.commonAncestorContainer, this.startContainer));
+				this.collapse(true);
+				// delete range
+				(function deleteSubtree(iterator) {
+					while (iterator.next()) {
+						if (iterator.hasPartialSubtree()) {
+							deleteSubtree(iterator.getSubtreeIterator());
+						} else {
+							iterator.remove();
+						}
+					}
+				})(new RangeIterator(range));
+			},
+			insertNode: function (newNode) {
+				// set original anchor and insert node
+				if (DOMUtils.isDataNode(this.startContainer)) {
+					DOMUtils.splitDataNode(this.startContainer, this.startOffset);
+					this.startContainer.parentNode.insertBefore(newNode, this.startContainer.nextSibling);
+				} else {
+					this.startContainer.insertBefore(newNode, this.startContainer.childNodes[this.startOffset]);
+				}
+				// resync start anchor
+				this.setStart(this.startContainer, this.startOffset);
+			},
+			surroundContents: function (newNode) {
+				// extract and surround contents
+				var content = this.extractContents();
+				this.insertNode(newNode);
+				newNode.appendChild(content);
+				this.selectNode(newNode);
+			},
+
+			// other methods
+			compareBoundaryPoints: function (how, sourceRange) {
+				// get anchors
+				var containerA, offsetA, containerB, offsetB;
+				switch (how) {
+				case DOMRange.START_TO_START:
+				case DOMRange.START_TO_END:
+					containerA = this.startContainer;
+					offsetA = this.startOffset;
+					break;
+				case DOMRange.END_TO_END:
+				case DOMRange.END_TO_START:
+					containerA = this.endContainer;
+					offsetA = this.endOffset;
+					break;
+				}
+				switch (how) {
+				case DOMRange.START_TO_START:
+				case DOMRange.END_TO_START:
+					containerB = sourceRange.startContainer;
+					offsetB = sourceRange.startOffset;
+					break;
+				case DOMRange.START_TO_END:
+				case DOMRange.END_TO_END:
+					containerB = sourceRange.endContainer;
+					offsetB = sourceRange.endOffset;
+					break;
+				}
+
+				// compare
+				return containerA.sourceIndex < containerB.sourceIndex ? -1 : containerA.sourceIndex == containerB.sourceIndex ? offsetA < offsetB ? -1 : offsetA == offsetB ? 0 : 1 : 1;
+			},
+			cloneRange: function () {
+				// return cloned range
+				var range = new DOMRange(this._document);
+				range.setStart(this.startContainer, this.startOffset);
+				range.setEnd(this.endContainer, this.endOffset);
+				return range;
+			},
+			detach: function () {
+				//[TODO] Releases Range from use to improve performance.
+			},
+			toString: function () {
+				return TextRangeUtils.convertFromDOMRange(this).text;
+			},
+			createContextualFragment: function (tagString) {
+				// parse the tag string in a context node
+				var
+				content = (DOMUtils.isDataNode(this.startContainer) ? this.startContainer.parentNode : this.startContainer).cloneNode(false),
+					fragment;
+
+				content.innerHTML = tagString;
+				// return a document fragment from the created node
+				for (fragment = this._document.createDocumentFragment(); content.firstChild;)
+				fragment.appendChild(content.firstChild);
+				return fragment;
+			}
+		};
+
+		/*
+	  Range iterator
+	 */
+		RangeIterator = function (range) {
+			this.range = range;
+			if (range.collapsed) {
+				return;
+			}
+
+			//[TODO] ensure this works
+			// get anchors
+			var root = range.commonAncestorContainer;
+			this._next = range.startContainer == root && !DOMUtils.isDataNode(range.startContainer) ? range.startContainer.childNodes[range.startOffset] : DOMUtils.findClosestAncestor(root, range.startContainer);
+			this._end = range.endContainer == root && !DOMUtils.isDataNode(range.endContainer) ? range.endContainer.childNodes[range.endOffset] : DOMUtils.findClosestAncestor(root, range.endContainer).nextSibling;
+		};
+
+		RangeIterator.prototype = {
+			// public properties
+			range: null,
+			// private properties
+			_current: null,
+			_next: null,
+			_end: null,
+
+			// public methods
+			hasNext: function () {
+				return !!this._next;
+			},
+			next: function () {
+				// move to next node
+				var current = this._current = this._next;
+				this._next = this._current && this._current.nextSibling != this._end ? this._current.nextSibling : null;
+
+				// check for partial text nodes
+				if (DOMUtils.isDataNode(this._current)) {
+					if (this.range.endContainer == this._current)
+					(current = current.cloneNode(true)).deleteData(this.range.endOffset, current.length - this.range.endOffset);
+					if (this.range.startContainer == this._current)
+					(current = current.cloneNode(true)).deleteData(0, this.range.startOffset);
+				}
+				return current;
+			},
+			remove: function () {
+				var end, start;
+				// check for partial text nodes
+				if (DOMUtils.isDataNode(this._current) && (this.range.startContainer == this._current || this.range.endContainer == this._current)) {
+					start = this.range.startContainer == this._current ? this.range.startOffset : 0;
+					end = this.range.endContainer == this._current ? this.range.endOffset : this._current.length;
+					this._current.deleteData(start, end - start);
+				} else this._current.parentNode.removeChild(this._current);
+			},
+			hasPartialSubtree: function () {
+				// check if this node be partially selected
+				return !DOMUtils.isDataNode(this._current) && (DOMUtils.isAncestorOrSelf(this._current, this.range.startContainer) || DOMUtils.isAncestorOrSelf(this._current, this.range.endContainer));
+			},
+			getSubtreeIterator: function () {
+				// create a new range
+				var subRange = new DOMRange(this.range._document);
+				subRange.selectNodeContents(this._current);
+				// handle anchor points
+				if (DOMUtils.isAncestorOrSelf(this._current, this.range.startContainer)) subRange.setStart(this.range.startContainer, this.range.startOffset);
+				if (DOMUtils.isAncestorOrSelf(this._current, this.range.endContainer)) subRange.setEnd(this.range.endContainer, this.range.endOffset);
+				// return iterator
+				return new RangeIterator(subRange);
+			}
+		};
+
+		/*
+	  DOM Selection
+	 */
+
+		//[NOTE] This is a very shallow implementation of the Selection object, based on Webkit's
+		// implementation and without redundant features. Complete selection manipulation is still
+		// possible with just removeAllRanges/addRange/getRangeAt.
+
+		DOMSelection = function (document) {
+			// save document parameter
+			this._document = document;
+
+			// add DOM selection handler
+			var selection = this;
+			document.attachEvent('onselectionchange', function () {
+				selection._selectionChangeHandler();
+			});
+		};
+
+		DOMSelection.prototype = {
+			// public properties
+			rangeCount: 0,
+			// private properties
+			_document: null,
+
+			// private methods
+			_selectionChangeHandler: function () {
+				// check if there exists a range
+				this.rangeCount = this._selectionExists(this._document.selection.createRange()) ? 1 : 0;
+			},
+			_selectionExists: function (textRange) {
+				// checks if a created text range exists or is an editable cursor
+				return textRange.compareEndPoints('StartToEnd', textRange) !== 0 || textRange.parentElement().isContentEditable;
+			},
+
+			// public methods
+			addRange: function (range) {
+				// add range or combine with existing range
+				var selection = this._document.selection.createRange(),
+					textRange = TextRangeUtils.convertFromDOMRange(range);
+				if (!this._selectionExists(selection)) {
+					// select range
+					textRange.select();
+				} else {
+					// only modify range if it intersects with current range
+					if (textRange.compareEndPoints('StartToStart', selection) == -1) if (textRange.compareEndPoints('StartToEnd', selection) > -1 && textRange.compareEndPoints('EndToEnd', selection) == -1) selection.setEndPoint('StartToStart', textRange);
+					else if (textRange.compareEndPoints('EndToStart', selection) < 1 && textRange.compareEndPoints('EndToEnd', selection) > -1) selection.setEndPoint('EndToEnd', textRange);
+					selection.select();
+				}
+			},
+			removeAllRanges: function () {
+				// remove all ranges
+				this._document.selection.empty();
+			},
+			getRangeAt: function (index) {
+				// return any existing selection, or a cursor position in content editable mode
+				var textRange = this._document.selection.createRange();
+				if (this._selectionExists(textRange)) return TextRangeUtils.convertToDOMRange(textRange, this._document);
+				return null;
+			},
+			toString: function () {
+				// get selection text
+				return this._document.selection.createRange().text;
+			}
+		};
+
+		/*
+	  scripting hooks
+	 */
+
+		document.createRange = function () {
+			return new DOMRange(document);
+		};
+
+		selection = new DOMSelection(document);
+		window.getSelection = function () {
+			return selection;
+		};
+
+		//[TODO] expose DOMRange/DOMSelection to window.?
+	}
+
+})(window);