riojs 0.0.0

data/public/javascripts/lib/page.js

@@ -0,0 +1,238 @@
+/**
+	@class
+	@extends rio.Attr
+	
+	Page is used to create page classes in a rio application.  It handles css dependencies, rendering, templating, 
+	layout management, and popup management.
+	
+	@author Jason Tillery
+	@copyright 2008-2009 Thinklink LLC
+*/
+rio.Page = {
+	create: function() {
+		var args = $A(arguments);
+		if (args.length > 0 && args.last() != undefined && !args.last().ATTR) {
+			args[args.size() - 1] = Object.extend({ noExtend: true }, args.last());
+		}
+		var page = rio.Attr.create.apply(this, args);
+
+		Object.extend(page, {
+			requireCss: function(name) {
+				rio.Application.includeCss("pages/" + name);
+			},
+			template: function(name) {
+				rio.boot.loadedTemplates.push(rio.boot.appRoot + "pages/" + name);
+
+				this._templateName = name;
+			},
+			applyTemplate: function() {
+				if (this._templateName && !this._templateApplied) {
+					var template = rio.JsTemplate.build("pages/" + this._templateName);
+					page.addMethods(template.mixinMethods());
+
+					this._templateApplied = true;
+				}
+			},
+			manageLayout: function() {
+				this.__manageLayout = true;
+			},
+			manageUndo: function() {
+				this.__manageUndo = true;
+			}
+		});
+		
+		page.addMethods({
+			html: function() {
+				if (!this._html) { this._html = this.buildHtml(); }
+				return this._html;
+			},
+			
+			popup: function() {
+				if (!this.__popupLightbox) { 
+					this.__popupLightbox = new rio.components.Lightbox({
+						content: this.html()
+					});
+				}
+				this.__popupLightbox.activate();
+				this.render();
+			},
+			
+			resizePopup: function() {
+				this.__popupLightbox.resize();
+			},
+			
+			closePopup: function(skipFade) {
+				this.__popupLightbox.deactivate(skipFade);
+			},
+			
+			isManagingLayout: function() {
+				return page.__manageLayout;
+			},
+			
+			_manageLayout: function() {
+				if (page.__manageLayout) { 
+					this.__lm = new rio.LayoutManager(this.html());
+				}
+			},
+			
+			layoutManager: function() {
+				return this.__lm;
+			},
+			
+			_afterRender: function() {
+				if (this.isManagingLayout()) {
+					(function() { this.__lm.resize(); }.bind(this)).defer();
+					(function() { this.__lm.resize(); }.bind(this)).delay(2);
+					(function() { this.__lm.resize(); }.bind(this)).delay(5);
+				}
+			},
+			
+			render: function() {
+				this._manageLayout();
+				this._afterRender();
+			},
+			
+			show: function() {
+				this.html().show();
+				this.resizePopup();
+			},
+			
+			hide: function() {
+				this.html().hide();
+			},
+			
+			addHistoryEntry: function(location, isTransient) {
+				rio.app.addHistoryEntry(location, isTransient);
+			},
+			
+			applyHistoryEntry: function() {
+				// Meant to be overriden
+			},
+			
+			keyPress: function(e) {
+				// Meant to be overriden
+			},
+			
+			keyDown: function(e) {
+				// Meant to be overriden
+			},
+			
+			resize: function() {
+				// Meant to be overriden
+			},
+			
+			getKeyMap: function() {
+				if (!this._keyMap) {
+					var maps = this.keyMap ? this.keyMap() : [];
+
+					if (page.__manageUndo) {
+						maps.push({
+							mac: { meta: true, shift: false, alt: false, key: "z" },
+							win: { ctrl: true, alt: false, key: "z" },
+							handler: function(e) {
+								if (e.target.value == undefined && this.undoShortcutsEnabled()) {
+									rio.Undo.undo();
+								}
+							}.bind(this)
+						});
+						maps.push({
+							mac: { meta: true, shift: true, alt: false, key: "z" },
+							win: { ctrl: true, alt: false, key: "y" },
+							handler: function(e) {
+								if (e.target.value == undefined && this.undoShortcutsEnabled()) {
+									rio.Undo.redo();
+									e.stop();
+								}	
+							}.bind(this)
+						});
+					}
+					this._keyMap = rio.KeyMap.build(maps);
+				}
+				return this._keyMap;
+			},
+			
+			enableUndoKeyboardShortcuts: function() {
+				this._undoShortuctsEnabled = true;
+			},
+
+			disableUndoKeyboardShortcuts: function() {
+				this._undoShortuctsEnabled = false;
+			},
+			
+			undoShortcutsEnabled: function() {
+				if (this._undoShortuctsEnabled == undefined) { this._undoShortuctsEnabled = true; }
+				return this._undoShortuctsEnabled;
+			},
+			
+			_keyDown: function(e) {
+				this.getKeyMap().handle(e);
+				this.keyDown(e);
+			},
+			
+			navigateTo: function(path) {
+				rio.app.navigateTo(path);
+			},
+			
+			refresh: function() {
+				rio.app.refresh();
+			},
+			
+			rootUrl: function() {
+				return rio.app.rootUrl();
+			},
+			
+			getCurrentLocation: function() {
+				return rio.app.getCurrentLocation();
+			},
+			
+			toString: function() {
+				return "[rio.pages.*]";
+			}
+		});
+		
+		// if (last arg is a concise syntax initializer)
+		if (args.length > 0 && args.last() != undefined && !args.last().ATTR) {
+			var initializers = args.last();
+			if (Object.isString(initializers.requireCss)) {
+				page.requireCss(initializers.requireCss);
+			}
+
+			if (Object.isString(initializers.template)) {
+				page.template(initializers.template);
+			}
+			if (Object.isString(initializers.jstemplate)) {
+				page.template(initializers.jstemplate);
+			}
+			
+			if (initializers.manageLayout) {
+				page.manageLayout();
+			}
+
+			if (initializers.manageUndo) {
+				page.manageUndo();
+			}
+
+			rio.Page.extend(page, initializers.methods || {});
+		}
+		
+		return page;
+	},
+	
+	extend: function(page, extension) {
+		extension._render = extension.render || Prototype.emptyFunction;
+		extension.render = function() {
+			this._manageLayout();
+			this._render();
+			this._afterRender();
+		};
+
+		extension.__initialize = extension.initialize || Prototype.emptyFunction;
+		extension.initialize = function(options) {
+			page.applyTemplate();
+		
+			(this.__initialize.bind(this))(options);
+		};
+
+		rio.Attr.extend(page, extension);
+	}
+};

data/public/javascripts/lib/parameters.js

@@ -0,0 +1,59 @@
+rio.Parameters = Class.create({
+	initialize: function(parameters, nonAjaxParameters) {
+		this.parameters = parameters;
+		this.nonAjaxParameters = nonAjaxParameters || {};
+	},
+	
+	ajaxParameters: function() {
+		var ajaxParameters = {};
+		Object.keys(this.parameters).each(function(parameter) {
+			var val = this.parameters[parameter];
+			if (val && val.not) {
+				// Do nothing.  Allow Object.toJSON to stringify it.
+			} else if (val && val !== true && val.toString) {
+				val = val.toString();
+			}
+			ajaxParameters[parameter.underscore()] = val;
+		}.bind(this));
+		return ajaxParameters;
+	},
+	
+	// ======================================================
+	// = THIS FUNCTION IS CALLED A MASSIVE AMOUNT OF TIMES. =
+	// ======================================================
+	/*
+		BE CAREFUL about what you add to this function.  It has been heavily
+		performance optimized.
+	*/
+	conditionFunction: function() {
+		return (function(obj) {
+			var evaluate = function(parameters) {
+				for (var parameter in parameters) {
+					var val = parameters[parameter];
+					var objVal = obj["_" + parameter];
+
+					if (val && val.not) {
+						if (objVal == val.not) { return false; }
+					} else {
+						var paramIsAnId = val && val.cacheKey;
+						var fieldIsAnId = objVal && objVal.cacheKey;
+						if (fieldIsAnId || paramIsAnId) {
+							if (fieldIsAnId && paramIsAnId) {
+								if (objVal.cacheKey() != val.cacheKey()) { return false; }
+							} else if (paramIsAnId) {
+								if (objVal != val.value()) { return false; }
+							} else {
+								if (objVal.value() != val) { return false; }
+							}
+						} else {
+							if (objVal != val) { return false; }
+						}
+					}
+				}
+				return true;
+			};
+			return evaluate(this.parameters) && evaluate(this.nonAjaxParameters);
+		}.bind(this));
+	}
+});
+rio.Parameters.toString = function() { return "Parameters"; };

data/public/javascripts/lib/png_fix.js

@@ -0,0 +1,75 @@
+// Copyright 2008, Thinklink
+// Adapted from:
+//  - sleight.js by Aaron Boodman
+//  - bgsleight.js by nater@naterkane.com
+//
+// dependencies - [builder, utils]
+
+rio.PngFix = Class.create();
+rio.PngFix.prototype = {
+	initialize: function() {
+		var platformIE = navigator.platform == "Win32" && navigator.appName == "Microsoft Internet Explorer" && window.attachEvent;
+		var browserIE = navigator.appVersion.match(/MSIE (\d+\.\d+)/, '');
+		var browserIEGT5 = (browserIE != null && Number(browserIE[1]) < 5.5);
+		var browserIELT7 = (browserIE != null && Number(browserIE[1]) < 7);
+
+		this._applicable = platformIE && browserIEGT5 && browserIELT7;
+	},
+	
+	loadPngs: function() {
+		if (this.isApplicable()) {
+			this.loadForegroundPngs();
+			this.loadBackgroundPngs();
+		}
+	},
+	
+	loadBackgroundPngs: function() {
+		for (var i = document.all.length - 1, obj = null; (obj = document.all[i]); i--) {
+			if (obj.currentStyle.backgroundImage.match(/\.png/i) != null) {
+				this.fixPng(obj);
+				obj.attachEvent("onpropertychange", this.propertyChanged);
+			}
+		}
+	},
+	
+	loadForegroundPngs: function() {
+		for (var i = document.images.length - 1, img = null; (img = document.images[i]); i--) {
+			if (img.src.match(/\.png$/i) != null) {
+				var imgHtml = rio.Tag.div('');
+				$(imgHtml).setStyle({
+					filter: "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + img.src + "', sizing='scale')",
+					width: img.width + "px",
+					height: img.height + "px"
+				});
+				Element.body().insert(imgHtml);
+				$(img).replace(imgHtml);
+			}
+		}
+	},
+
+	propertyChanged: function() {
+		if (window.event.propertyName == "style.backgroundImage") {
+			var el = window.event.srcElement;
+			if (!el.currentStyle.backgroundImage.match(/transparent\.gif/i)) {
+				var bg	= el.currentStyle.backgroundImage;
+				var src = bg.substring(5,bg.length-2);
+				el.filters.item(0).src = src;
+				el.style.backgroundImage = "url(/images/blank.gif)";
+			}
+		}
+	},
+
+	fixPng: function(obj) {
+		var bg	= obj.currentStyle.backgroundImage;
+		var src = bg.substring(5,bg.length-2);
+		var sizingMethod = (obj.currentStyle.backgroundRepeat == "no-repeat") ? "crop" : "scale";
+		obj.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(src='" + src + "', sizingMethod='" + sizingMethod + "')";
+		obj.style.backgroundImage = "url(/images/blank.gif)";
+	},
+	
+	isApplicable: function() {
+		return this._applicable;
+	}
+};
+
+Event.observe(window, "load", function() { new rio.PngFix().loadPngs(); });

data/public/javascripts/lib/protohack.js

@@ -0,0 +1,297 @@
+if (Prototype.Browser.WebKit) {
+	Object.extend(Event, {
+		// This does not appear to be the case now
+		// KEY_LEFT:     63234,
+		// KEY_UP:       63232,
+		// KEY_RIGHT:    63235,
+		// KEY_DOWN:     63233,
+		// KEY_DELETE:   63272,
+		KEY_HOME:     63273,
+		KEY_END:      63275,
+		KEY_PAGEUP:   63276,
+		KEY_PAGEDOWN: 63277
+	});
+}
+
+Object.extend(Element, {
+	body: function() {
+		return $$('body')[0];
+	},
+	
+	head: function() {
+		return $$('head')[0];
+	},
+	
+	html: function() {
+		return $$('html')[0];
+	},
+	
+	isRendered: function(elt) {
+		return elt.descendantOf(Element.body());
+	},
+	
+	toPixels: function(val) {
+		if (!val) { return val; }
+		
+		if (Object.isNumber(val)) { return val + "px"; }
+		if (Object.isString(val) && val.match(/^-?\d*$/)) { return val + "px"; }
+		
+		return val;
+	},
+	
+	pixeledAttributes: [
+		"width", "height",
+		"padding", "paddingTop", "paddingRight", "paddingBottom", "paddingLeft",
+		"margin", "marginTop", "marginRight", "marginBottom", "marginLeft",	
+		"top", "bottom", "left", "right",
+		"fontSize"
+	]
+});
+
+Element.addMethods({
+	totalHeight: function(elt) {
+		return ["height", "margin-top", "margin-bottom", "padding-top", "padding-bottom", "border-top-width", "border-bottom-width"].inject(0, function(acc, prop) {
+			return acc + (parseInt(elt.getStyle(prop), 0) || 0);
+		});
+	},
+	
+	addHoverClass: function(elt, hoverClass, focusClass) {
+		elt = $(elt);
+		elt.observe('mouseover', function() {
+			elt.addClassName(hoverClass);
+		});
+		elt.observe('mouseout', function() {
+			elt.removeClassName(hoverClass);
+		});
+		if (focusClass) {
+			elt.observe('focus', function() {
+				elt.addClassName(focusClass);
+				elt.removeClassName(hoverClass);
+			});
+			elt.observe('blur', function() {
+				elt.removeClassName(focusClass);
+			});
+		}
+	},
+	
+	insert: Element.insert.wrap(function(proceed, elt, insertions) {
+		var newInsertions;
+		if (insertions.html) {
+			newInsertions = insertions.html();
+		} else if (insertions.top || insertions.bottom || insertions.before || insertions.after) {
+			newInsertions = {};
+			Object.keys(insertions).each(function(position) {
+				newInsertions[position] = insertions[position].html ? insertions[position].html() : insertions[position];
+			});
+		} else {
+			newInsertions = insertions;
+		}
+		
+		proceed(elt, newInsertions);
+	}),
+	
+	applyStyle: function(elt, styles) {
+		var toApply = {};
+		var styleBinding = function(val) {
+			var style = {};
+			style[styleName] = Element.pixeledAttributes.include(styleName) ? Element.toPixels(val) : val;
+			elt.setStyle(style);
+		};
+		for (styleName in styles) {
+			var val = styles[styleName]; //.THEME ? styles[styleName]() : styles[styleName];
+			if (val == undefined) {
+				// Do nothing
+			} else if (val.BINDING) {
+				val.bind(styleBinding, true);
+				var newValue = Element.pixeledAttributes.include(styleName) ? Element.toPixels(val.value()) : val.value();
+				if (newValue !== undefined) {
+					toApply[styleName] = newValue;
+				}
+			} else {
+				toApply[styleName] = Element.pixeledAttributes.include(styleName) ? Element.toPixels(val) : val;
+			}
+		}
+		elt.setStyle(toApply);
+	},
+
+	horizontalMBP: function(elt) {
+		return elt.totalPixelsForStyles(["marginLeft", "marginRight", "borderLeftWidth", "borderRightWidth", "paddingLeft", "paddingRight"]);
+	},
+	
+	verticalMBP: function(elt) {
+		return elt.totalPixelsForStyles(["marginTop", "marginBottom", "borderTopWidth", "borderBottomWidth", "paddingTop", "paddingBottom"]);
+	},
+	
+	totalPixelsForStyles: function(elt, styles) {
+		return styles.inject(0, function(acc, s) {
+			var val = parseInt(elt.getStyle(s).stripPx() || 0, 10);
+			if (isNaN(val)) {  // Test for IE!!
+				val = 0;
+			}
+			return acc + val;
+		});
+	}
+	
+});
+
+if (rio.environment.logEventErrors) {
+	Event.observe = Event.observe.wrap(function(proceed, element, eventName, handler) {
+		var newHandler = handler.wrap(function(proceed) {
+			try {
+				proceed.apply(proceed, $A(arguments).slice(1));
+			} catch(e) {
+				rio.error(e, "Error processing event: " + element + "#" + eventName);
+				throw(e);
+			}
+		});
+		proceed(element, eventName, newHandler);
+	});
+	
+	Element.addMethods({
+	  observe: Event.observe
+	});
+
+	Object.extend(document, {
+	  observe: Element.Methods.observe.methodize()
+	});
+	
+	Ajax.Request.prototype.dispatchException = Ajax.Request.prototype.dispatchException.wrap(function(proceed, exception) {
+		rio.error(exception, "Error processing Ajax callback: ");
+		proceed(exception);
+	});
+}
+
+Object.extend(Date.prototype, {
+	strftime: function(format) {
+		var day = this.getUTCDay(), month = this.getUTCMonth();
+		var hours = this.getUTCHours(), minutes = this.getUTCMinutes();
+		function pad(num) { return num.toPaddedString(2); }
+
+		return format.gsub(/\%([aAbBcdDHiImMpSwyY])/, function(part) {
+			switch(part[1]) {
+				case 'a': return $w("Sun Mon Tue Wed Thu Fri Sat")[day];
+				case 'A': return $w("Sunday Monday Tuesday Wednesday Thursday Friday Saturday")[day];
+				case 'b': return $w("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec")[month];
+				case 'B': return $w("January February March April May June July August September October November December")[month];
+				case 'c': return this.toString();
+				case 'd': return pad(this.getUTCDate());
+				case 'D': return pad(this.getUTCDate());
+				case 'H': return pad(hours);
+				case 'i': return (hours === 12 || hours === 0) ? 12 : (hours + 12) % 12;
+				case 'I': return pad((hours === 12 || hours === 0) ? 12 : (hours + 12) % 12);
+				case 'm': return pad(month + 1);
+				case 'M': return pad(minutes);
+				case 'p': return hours > 11 ? 'PM' : 'AM';
+				case 'S': return pad(this.getUTCSeconds());
+				case 'w': return day;
+				case 'y': return pad(this.getUTCFullYear() % 100);
+				case 'Y': return this.getUTCFullYear().toString();
+			}
+		}.bind(this));
+	},
+
+	prettyTime: function() {
+		return this.getHours() + ":" + 
+		this.getMinutes().toPaddedString(2) + ":" + 
+		this.getSeconds().toPaddedString(2);
+	}
+});
+
+Object.extend(Date, {
+	/*
+		Adapted from (http://delete.me.uk/2005/03/iso8601.html)
+	*/
+	parseISO: function(string) {
+	    var regexp = "([0-9]{4})(-([0-9]{2})(-([0-9]{2})(T([0-9]{2}):([0-9]{2})(:([0-9]{2})(/.([0-9]+))?)?(Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?";
+	    var d = string.match(new RegExp(regexp));
+
+	    var offset = 0;
+	    var date = new Date(d[1], 0, 1);
+
+	    if (d[3]) { date.setMonth(d[3] - 1); }
+	    if (d[5]) { date.setDate(d[5]); }
+	    if (d[7]) { date.setHours(d[7]); }
+	    if (d[8]) { date.setMinutes(d[8]); }
+	    if (d[10]) { date.setSeconds(d[10]); }
+	    if (d[12]) { date.setMilliseconds(Number("0." + d[12]) * 1000); }
+	    if (d[14]) {
+	        offset = (Number(d[16]) * 60) + Number(d[17]);
+	        offset *= ((d[15] == '-') ? 1 : -1);
+	    }
+
+		// I had to add the * 2 to get it to work
+	    offset -= date.getTimezoneOffset() * 2;
+	    time = (Number(date) + (offset * 60 * 1000));
+		
+		return new Date(Number(time));
+	}
+});
+
+Object.extend(String.prototype, {
+	camelize: function() {
+		var parts = this.split(/_|-/), len = parts.length;
+		if (len == 1) { return parts[0]; }
+
+		var camelized = this.charAt(0) == '-' || this.charAt(0) == '_' ? 
+			parts[0].charAt(0).toUpperCase() + parts[0].substring(1) : parts[0];
+
+		for (var i = 1; i < len; i++) {
+			camelized += parts[i].charAt(0).toUpperCase() + parts[i].substring(1);
+		}
+
+		return camelized;
+	},
+	
+	stripPx: function() {
+		return Number(this.endsWith("px") ? this.match(/(.*)px/)[1] : this);
+	},
+	
+	classize: function() {
+		if (this.length == 0) { return ""; }
+		if (this.length == 1) { return this.capitalize(); }
+		
+		return this.capitalize().slice(0,1) + this.camelize().slice(1);
+	},
+	
+	isNumeric: function() {
+	  return parseFloat(this) + '' == parseFloat(this);
+	},
+	
+	toBoolean: function() {
+		return this.toLowerCase() == "true";
+	},
+	
+	validEmail: function() {
+		return this.match(/^([^@\s]+)@((?:[\-a-z0-9]+\.)+[a-z]{2,})$/i);
+	}
+});
+
+Object.extend(Number.prototype, {
+	stripPx: function() {
+		return this;
+	}
+});
+
+Object.extend(Array.prototype, {
+	destroy: function(item) {
+		this.splice(this.indexOf(item), 1);
+		item.destroy();
+	},
+	
+	empty: function() {
+		return this.size() == 0;
+	}
+});
+
+// This is a superior implementation, developed by Douglas Crockford
+// this function unfortunately treats the HTMLSelectElement as an array :(
+Object.isArray = function(testObject) {
+	return testObject && !(testObject.propertyIsEnumerable != undefined && testObject.propertyIsEnumerable('length')) && typeof testObject === 'object' && typeof testObject.length === 'number' && !(testObject.tagName == "SELECT");
+};
+
+Prototype.Browser.IE6 = Prototype.Browser.IE && parseInt(navigator.userAgent.substring(navigator.userAgent.indexOf("MSIE")+5), 10)==6;
+Prototype.Browser.IE7 = Prototype.Browser.IE && parseInt(navigator.userAgent.substring(navigator.userAgent.indexOf("MSIE")+5), 10)==7;
+Prototype.Browser.IE8 = Prototype.Browser.IE && parseInt(navigator.userAgent.substring(navigator.userAgent.indexOf("MSIE")+5), 10)==8;
+
+
+