riojs 0.0.0

data/public/javascripts/lib/juggernaut.js

@@ -0,0 +1,295 @@
+/*
+	Copyright (c) 2008 Alexander MacCaw
+
+	Permission is hereby granted, free of charge, to any person obtaining
+	a copy of this software and associated documentation files (the
+	"Software"), to deal in the Software without restriction, including
+	without limitation the rights to use, copy, modify, merge, publish,
+	distribute, sublicense, and/or sell copies of the Software, and to
+	permit persons to whom the Software is furnished to do so, subject to
+	the following conditions:
+
+	The above copyright notice and this permission notice shall be
+	included in all copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+	LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+	OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+	WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+/* This variable has to be left here because Juggernaut.swf expects it. */
+var juggernaut;
+
+/**
+	@class
+	
+	<p>Juggernaut is a utility that allows the server to initiate connections with the browser.</p>
+	<p>This is what facilitates the client-server bindings that allow for automatic-collborative models.</p>
+	<p><i>Note: this version of Juggernaut has been altered to work better with the rio framework.</i></p>
+*/
+rio.Juggernaut = Class.create({
+	initialize: function(options) {
+		this.is_connected = false;
+		this.attempting_to_reconnect = false;
+		this.ever_been_connected = false;
+		this.options = options;
+		if(!this.options.client_id) { 
+			this.options.client_id = this.options.session_id;
+		}
+
+		this.bindToWindow();
+		
+		var connectionAttr = new rio.Attr.create({
+			attrAccessors: [["live", false]]
+		});
+		this.live = (new connectionAttr()).live;
+	},
+
+	logger: function(msg) {
+		if (this.options.debug) {
+			msg = "Juggernaut: " + msg + " on " + this.options.host + ':' + this.options.port;
+			rio.log(msg);
+		}
+	},
+
+	initialized: function(){
+		this.fire_event('initialized');
+		this.connect();
+	},
+
+	broadcast: function(body, type, client_ids, channels){
+		var msg = { command: 'broadcast', body: body, type: (type||'to_channels') };
+		if(channels) { msg.channels = channels; }
+		if(client_ids) { msg.client_ids = client_ids; }
+		msg.client_id = this.options.client_id;
+		msg.session_id = this.options.session_id;
+		this.sendData(this.toJSON(msg));
+	},
+
+	sendData: function(data){
+		this.swf().sendData(escape(data));
+	},
+
+	connect: function(){
+		if(!this.is_connected){
+			this.fire_event('connect');
+			this.swf().connect(this.options.host, this.options.port);
+		}
+	},
+
+	disconnect: function(){
+		if(this.is_connected) {
+			this.swf().disconnect();
+			this.is_connected = false;
+			this.live.update(false);
+		}
+	},
+	
+	addChannel: function(channelName) {
+		this.options.channels.push(channelName);
+		this.resetConnection();	
+	},
+	
+	// Added to facilitate subscription to new channels
+	resetConnection: function() {
+		if (!this._resetTask) { this._resetTask = new rio.DelayedTask(); }
+		this._resetTask.delay(100, function() {
+			if (!(this.swf() && this.swf().connect)) { 
+				this.resetConnection.bind(this).delay(500); 
+				return;
+			}
+			this.disconnect();
+			this.connect();
+		}.bind(this));
+	},
+
+	handshake: function() {
+		var handshake = {};
+		handshake.command = 'subscribe';
+		if(this.options.session_id) { handshake.session_id = this.options.session_id; }
+		if(this.options.client_id) { handshake.client_id = this.options.client_id; }
+		if(this.options.channels) { handshake.channels = this.options.channels; }
+		if(this.currentMsgId) {
+			handshake.last_msg_id = this.currentMsgId;
+			handshake.signature = this.currentSignature;
+		}
+
+		return handshake;
+	},
+
+	connected: function(e) {
+		var json = this.toJSON(this.handshake());
+		this.sendData(json);
+		this.ever_been_connected = true;
+		this.is_connected = true;
+		this.live.update(true);
+		setTimeout(function(){
+			if(this.is_connected) { this.attempting_to_reconnect = false; }
+		}.bind(this), 1 * 1000);
+		this.logger('Connected');
+		this.fire_event('connected');
+	},
+
+	// OVERRIDE FOR CHAT STYLE APPS - POSSIBLE MALICIOUS CONTENT CAN BE EVALED
+	receiveData: function(e) {
+		var msg = this.parseJSON(unescape(e.toString()));
+		this.currentMsgId = msg.id;
+		this.currentSignature = msg.signature;
+		
+		if (msg.body.startsWith("rio.console.touch")) {
+			// don't log autospec stuff
+		} else {
+			this.logger("Received data:\n" + msg.body + "\n");
+		}
+		eval(msg.body); 
+	},
+
+	/*** START PROTOTYPE SPECIFIC - OVERRIDE FOR OTHER FRAMEWORKS ***/
+	fire_event: function(fx_name) {
+		$(document).fire("juggernaut:" + fx_name);
+	},
+
+	bindToWindow: function() {
+		window.juggernaut = this;
+		this.appendFlashObject();
+	},
+
+	toJSON: function(hash) {
+		return Object.toJSON(hash);
+	},
+
+	parseJSON: function(string) {
+		return string.evalJSON();
+	},
+
+	swf: function(){
+		return $(this.options.swf_name);    
+	},
+
+	appendElement: function() {
+		this.element = new Element('div', { id: 'juggernaut' });
+		$(document.body).insert({ bottom: this.element });
+	},
+
+	/*** END PROTOTYPE SPECIFIC ***/
+
+	appendFlashObject: function(){
+		if(this.swf()) {
+			throw("Juggernaut error. 'swf_name' must be unique per juggernaut instance.");
+		}
+		this.appendElement();
+		rio.swfobject.embedSWF(
+			this.options.swf_address, 
+			'juggernaut', 
+			this.options.width, 
+			this.options.height, 
+			String(this.options.flash_version),
+			this.options.ei_swf_address,
+			{'bridgeName': this.options.bridge_name},
+			{},
+			{'id': this.options.swf_name, 'name': this.options.swf_name}
+		);
+	},
+
+	refreshFlashObject: function(){
+		this.swf().remove();
+		this.appendFlashObject();
+	},
+
+	errorConnecting: function(e) {
+		this.is_connected = false;
+		this.live.update(false);
+		if(!this.attempting_to_reconnect) {
+			this.logger('There has been an error connecting');
+			this.fire_event('errorConnecting');
+			this.reconnect();
+		}
+	},
+
+	disconnected: function(e) {
+		this.is_connected = false;
+		this.live.update(false);
+		if(!this.attempting_to_reconnect) {
+			this.logger('Connection has been lost');
+			this.fire_event('disconnected');
+			this.reconnect();
+		}
+	},
+
+	reconnect: function(){
+		if(this.options.reconnect_attempts){
+			this.attempting_to_reconnect = true;
+			this.live.update(false);
+			this.fire_event('reconnect');
+			this.logger('Will attempt to reconnect ' + this.options.reconnect_attempts + ' times,' +
+			'the first in ' + (this.options.reconnect_intervals || 3) + ' seconds');
+			var attemptReconnect = function(){
+				if(!this.is_connected){
+					this.logger('Attempting reconnect');
+					if(!this.ever_been_connected){
+						this.refreshFlashObject();
+					} else {
+						this.connect();
+					}
+				}
+			}.bind(this);
+			for(var i=0; i < this.options.reconnect_attempts; i++){
+				setTimeout(attemptReconnect, (this.options.reconnect_intervals || 3) * 1000 * (i + 1));
+			}
+		}
+	}
+});
+
+rio.Juggernaut.boot = function() {
+	var push = new rio.Juggernaut({
+		ei_swf_address: "/javascripts/lib/expressinstall.swf", 
+		reconnect_intervals: 3, 
+		flash_version: 8, 
+		channels: [],
+		session_id: rio.environment.sessionId,
+		client_id: rio.environment.userId || Math.round(Math.random() * -1000000000),
+		host: rio.environment.pushUrl, 
+		width: "0px", 
+		height: "0px", 
+		flash_color: "#fff", 
+		swf_name: "juggernaut_flash", 
+		port: rio.environment.pushPort, 
+		bridge_name: "juggernaut", 
+		debug: rio.environment.pushDebug, 
+		swf_address: "/javascripts/lib/juggernaut.swf", 
+		reconnect_attempts: 3
+	});
+
+	setInterval(function() {
+		if (rio.push) {
+			if (!rio.push.is_connected) { 
+				rio.push.connect();
+			} else {
+				new Ajax.Request("/push/test_connection", {
+					method: "get",
+					asynchronous: true,
+					evalJS: false,
+					evalJSON: false,
+					onSuccess: function(response) {
+						if (response.responseText != "CONNECTED") {
+							rio.warn("Juggernaut connection silently failed");
+							rio.push.resetConnection();
+						}
+					}
+				});
+			}
+		}
+	}, 60000);
+
+	return push;
+};
+
+
+
+
+
+

data/public/javascripts/lib/key_map.js

@@ -0,0 +1,60 @@
+rio.KeyMap = Class.create({
+	initialize: function(map, isMac) {
+		this.map = map;
+		this.isMac = isMac;
+	},
+	
+	handle: function(e) {
+		this.map.each(function(m) {
+			var map = m.map || (this.isMac ? m.mac : m.win);
+
+			if (Object.isString(map.key)) { 
+				map.key = rio.KeyMap.specialKeys()[map.key] || rio.KeyMap.charCode(map.key);
+			}
+
+			var effectiveKeyCode = (e.keyCode >= 96 && e.keyCode <= 105) ? e.keyCode - 48 : e.keyCode;
+			if (map.key == effectiveKeyCode) {
+				if (map.ctrl == undefined || map.ctrl == e.ctrlKey) {
+					if (map.alt == undefined || map.alt == e.altKey) {
+						if (map.shift == undefined || map.shift == e.shiftKey) {
+							if (map.meta == undefined || map.meta == e.metaKey) {
+								(m.handler || Prototype.emptyFunction)(e);
+								
+								if (m.stop) {
+									e.stop();
+								}
+							}
+						}
+					}
+				}
+			}
+		}.bind(this));
+	}
+});
+
+Object.extend(rio.KeyMap, {
+	build: function(map) {
+		return new rio.KeyMap(map, rio.boot.isMac);
+	},
+	charCode: function(c) {
+		return "0123456789_______abcdefghijklmnopqrstuvwxyz".indexOf(c) + 48;
+	},
+	specialKeys: function() {
+		return {
+			"left": Event.KEY_LEFT,
+			"right": Event.KEY_RIGHT,
+			"up": Event.KEY_UP,
+			"down": Event.KEY_DOWN,
+			"tab": Event.KEY_TAB,
+			"enter": Event.KEY_RETURN,
+			"home": Event.KEY_HOME,
+			"end": Event.KEY_END,
+			"backspace": Event.KEY_BACKSPACE,
+			"delete": Event.KEY_DELETE,
+			"space": 32,
+			"esc": Event.KEY_ESC,
+			",": 188
+		};
+	},
+	toString: function() { return "KeyMap"; }
+});

data/public/javascripts/lib/layout_manager.js

@@ -0,0 +1,167 @@
+// Layout container to handle one container with lm_left, lm_right, lm_top, lm_bottom, and lm_center
+rio.LayoutContainer = Class.create({
+  initialize: function(root) {   
+    this.parent = $(root.parentNode); 
+    root.setStyle("padding:0; margin:0; border:0"); 
+    // Pre-compute paddings
+    $w("top left right bottom").each(function(key) { 
+      this.parent[key] = this.padding(this.parent, key);
+    }.bind(this));
+    
+    // Init arrays
+    $w("lm_top lm_left lm_right lm_bottom lm_center").each(function(key) {
+      this[key] = [];
+    }.bind(this));
+    
+    root.childElements().each(function(element) {
+      element.style.position = "absolute";
+      element.paddingWidth   = this.fullPadding(element, "left") + this.fullPadding(element, "right");
+      element.paddingHeight  = this.fullPadding(element, "top") + this.fullPadding(element, "bottom");
+      element.marginWidth    = this.margin(element, "left") + this.margin(element, "right");
+      element.marginHeight   = this.margin(element, "top") + this.margin(element, "bottom");
+      
+      if (element.hasClassName("lm_top")) {
+        this.lm_top.push(element);
+      } else if (element.hasClassName("lm_left")) {
+        this.lm_left.push(element);  
+      } else if (element.hasClassName("lm_right")) {
+        this.lm_right.unshift(element);
+      } else if (element.hasClassName("lm_bottom")) {
+        this.lm_bottom.unshift(element);  
+      } else if (element.hasClassName("lm_center")) {
+        if (this.lm_center.length > 0) {
+          throw("Only one lm_center per lm_container");
+		}
+        this.lm_center.push(element);
+      }
+    }.bind(this));
+  },
+  
+  updateSize: function() {      
+    var d = this.parent.getDimensions();
+    var w = d.width - this.parent.left - this.border(this.parent, "left") - this.border(this.parent, "right");
+    var h = d.height - this.parent.top - this.parent.bottom  - this.border(this.parent, "top") - this.border(this.parent, "bottom");
+    var that = this; // To avoid too many binds
+   
+    // Set position and size of all top elements  
+    var top = this.parent.top;     
+    this.lm_top.each(function(element) {   
+      var s = element.style;   
+      that.setPositivePxValue(s, 'width', w - element.paddingWidth);
+      s.top = top + "px";
+      top += element.getHeight() + element.marginHeight;
+    });
+    h -= top - this.parent.top;
+    
+    // Set position and size of all bottom elements
+    var bottom = this.parent.bottom;
+    this.lm_bottom.each(function(element) { 
+      var s = element.style;   
+      that.setPositivePxValue(s, 'width', w - element.paddingWidth);
+      s.bottom = bottom + "px";
+      bottom += element.getHeight() + element.marginHeight;
+    });
+    h -= bottom - this.parent.bottom;
+     
+    // Set position and size of all left elements
+    var left = this.parent.left;          
+    this.lm_left.each(function(element) {
+      var s = element.style;  
+      that.setPositivePxValue(s, 'height', h - element.paddingHeight);
+      s.top  = top + "px";  
+      s.left = left + "px";  
+      left += element.getWidth() + element.marginWidth;
+    });
+    w -= left;
+    
+    // Set position and size of all right elements
+    var right = this.parent.right;
+    this.lm_right.each(function(element) {
+      var s = element.style;
+      that.setPositivePxValue(s, 'height', h - element.paddingHeight);
+      s.top   = top + "px";  
+      s.right = right + "px";  
+      right += element.getWidth() + element.marginWidth;
+    });
+    w -= right;
+     
+    // Set position and size of all center elements
+    // Only one center for this version
+    var center = this.lm_center.first();
+    var s = center.style;
+    s.top  = top + "px"; 
+    s.left = left + "px";  
+    this.setPositivePxValue(s, 'width', w - center.paddingWidth);
+    this.setPositivePxValue(s, 'height', h - center.paddingHeight);
+  },
+     
+  // Private functions
+  fullPadding: function(element, s) {   
+    return this.padding(element, s) + this.border(element, s) + this.margin(element, s);
+  },
+
+  border: function(element, s) {   
+    var border = parseInt(element.getStyle("border-" + s + "-width") || 0, 10);
+    if (isNaN(border)) { // Test for IE!!
+      border = 0;
+	}
+    return border;
+  },
+
+  padding: function(element, s) {   
+    var padding = parseInt(element.getStyle("padding-" + s) || 0, 10);
+    if (isNaN(padding)) {   // Test for IE!!
+       padding = 0;
+	}
+    return padding;
+  },
+
+  margin: function(element, s) {   
+    var margin = parseInt(element.getStyle("margin-" + s) || 0, 10);
+    if (isNaN(margin)) {  // Test for IE!!
+       margin = 0;
+	}
+    return margin;
+  },
+  
+  setPositivePxValue:function(objet, key, value) {
+    objet[key] =  (value > 0 ? value : 0) + "px";
+  }
+});
+                 
+// Layout manager: handles N layout container
+rio.LayoutManager = Class.create({
+  initialize: function(root) {
+    this.root = root || document.body;
+    this.init();
+    Event.observe(window, "resize", this.resize.bind(this));
+  },
+  
+  reset: function() {
+    this.init.bind(this).defer();
+  }, 
+  
+  add: function(root) {       
+    this.addElement.bind(this, root, true).defer();
+  },
+  
+  // Private functions
+  init: function() {
+    this.containers = [];
+    this.addElement(this.root);  
+    this.resize();    
+  },
+  
+  resize: function() {
+   	this.containers.invoke("updateSize"); 
+  },
+  
+  addElement: function(element, doResize) {
+    $(element).getElementsBySelector(".lm_container").each(function(element) {
+      this.containers.push(new rio.LayoutContainer(element));
+    }.bind(this));
+    if (doResize) {
+      this.resize();
+	}
+  }
+});