radiant-rc 0.9.0

data/public/javascripts/admin/lowpro.js

@@ -0,0 +1,339 @@
+LowPro = {};
+LowPro.Version = '0.5';
+LowPro.CompatibleWithPrototype = '1.6';
+
+if (Prototype.Version.indexOf(LowPro.CompatibleWithPrototype) != 0 && window.console && window.console.warn)
+  console.warn("This version of Low Pro is tested with Prototype " + LowPro.CompatibleWithPrototype + 
+                  " it may not work as expected with this version (" + Prototype.Version + ")");
+
+if (!Element.addMethods) 
+  Element.addMethods = function(o) { Object.extend(Element.Methods, o) };
+
+// Simple utility methods for working with the DOM
+DOM = {};
+
+// DOMBuilder for prototype
+DOM.Builder = {
+	tagFunc : function(tag) {
+    return function() {
+     var attrs, children;
+     if (arguments.length>0) {
+       if (arguments[0].constructor == Object) {
+         attrs = arguments[0];
+         children = Array.prototype.slice.call(arguments, 1);
+       } else {
+         children = arguments;
+       };
+       children = $A(children).flatten()
+     }
+     return DOM.Builder.create(tag, attrs, children);
+    };
+  },
+	create : function(tag, attrs, children) {
+		attrs = attrs || {}; children = children || []; tag = tag.toLowerCase();
+		var el = new Element(tag, attrs);
+	  
+		for (var i=0; i<children.length; i++) {
+			if (typeof children[i] == 'string') 
+			  children[i] = document.createTextNode(children[i]);
+			el.appendChild(children[i]);
+		}
+		return $(el);
+	}
+};
+
+// Automatically create node builders as $tagName.
+(function() { 
+	var els = ("p|div|span|strong|em|img|table|tr|td|th|thead|tbody|tfoot|pre|code|" + 
+				     "h1|h2|h3|h4|h5|h6|ul|ol|li|form|input|textarea|legend|fieldset|" + 
+				     "select|option|blockquote|cite|br|hr|dd|dl|dt|address|a|button|abbr|acronym|" +
+				     "script|link|style|bdo|ins|del|object|param|col|colgroup|optgroup|caption|" + 
+				     "label|dfn|kbd|samp|var").split("|");
+  var el, i=0;
+	while (el = els[i++]) 
+	  window['$' + el] = DOM.Builder.tagFunc(el);
+})();
+
+DOM.Builder.fromHTML = function(html) {
+  var root;
+  if (!(root = arguments.callee._root))
+    root = arguments.callee._root = document.createElement('div');
+  root.innerHTML = html;
+  return root.childNodes[0];
+};
+
+
+
+// Wraps the 1.6 contentloaded event for backwards compatibility
+//
+// Usage:
+//
+// Event.onReady(callbackFunction);
+Object.extend(Event, {
+  onReady : function(f) {
+    if (document.body) f();
+    else document.observe('dom:loaded', f);
+  }
+});
+
+// Based on event:Selectors by Justin Palmer
+// http://encytemedia.com/event-selectors/
+//
+// Usage:
+//
+// Event.addBehavior({
+//      "selector:event" : function(event) { /* event handler.  this refers to the element. */ },
+//      "selector" : function() { /* runs function on dom ready.  this refers to the element. */ }
+//      ...
+// });
+//
+// Multiple calls will add to exisiting rules.  Event.addBehavior.reassignAfterAjax and
+// Event.addBehavior.autoTrigger can be adjusted to needs.
+Event.addBehavior = function(rules) {
+  var ab = this.addBehavior;
+  Object.extend(ab.rules, rules);
+  
+  if (!ab.responderApplied) {
+    Ajax.Responders.register({
+      onComplete : function() { 
+        if (Event.addBehavior.reassignAfterAjax) 
+          setTimeout(function() { ab.reload() }, 10);
+      }
+    });
+    ab.responderApplied = true;
+  }
+  
+  if (ab.autoTrigger) {
+    this.onReady(ab.load.bind(ab, rules));
+  }
+  
+};
+
+Event.delegate = function(rules) {
+  return function(e) {
+      var element = $(e.element());
+      for (var selector in rules)
+        if (element.match(selector)) return rules[selector].apply(this, $A(arguments));
+    }
+}
+
+Object.extend(Event.addBehavior, {
+  rules : {}, cache : [],
+  reassignAfterAjax : false,
+  autoTrigger : true,
+  
+  load : function(rules) {
+    for (var selector in rules) {
+      var observer = rules[selector];
+      var sels = selector.split(',');
+      sels.each(function(sel) {
+        var parts = sel.split(/:(?=[a-z]+$)/), css = parts[0], event = parts[1];
+        $$(css).each(function(element) {
+          if (event) {
+            var wrappedObserver = Event.addBehavior._wrapObserver(observer);
+            $(element).observe(event, wrappedObserver);
+            Event.addBehavior.cache.push([element, event, wrappedObserver]);
+          } else {
+            if (!element.$$assigned || !element.$$assigned.include(observer)) {
+              if (observer.attach) observer.attach(element);
+              
+              else observer.call($(element));
+              element.$$assigned = element.$$assigned || [];
+              element.$$assigned.push(observer);
+            }
+          }
+        });
+      });
+    }
+  },
+  
+  unload : function() {
+    this.cache.each(function(c) {
+      Event.stopObserving.apply(Event, c);
+    });
+    this.cache = [];
+  },
+  
+  reload: function() {
+    var ab = Event.addBehavior;
+    ab.unload(); 
+    ab.load(ab.rules);
+  },
+  
+  _wrapObserver: function(observer) {
+    return function(event) {
+      if (observer.call(this, event) === false) event.stop(); 
+    }
+  }
+  
+});
+
+Event.observe(window, 'unload', Event.addBehavior.unload.bind(Event.addBehavior));
+
+// A silly Prototype style shortcut for the reckless
+$$$ = Event.addBehavior.bind(Event);
+
+// Behaviors can be bound to elements to provide an object orientated way of controlling elements
+// and their behavior.  Use Behavior.create() to make a new behavior class then use attach() to
+// glue it to an element.  Each element then gets it's own instance of the behavior and any
+// methods called onxxx are bound to the relevent event.
+// 
+// Usage:
+// 
+// var MyBehavior = Behavior.create({
+//   onmouseover : function() { this.element.addClassName('bong') } 
+// });
+//
+// Event.addBehavior({ 'a.rollover' : MyBehavior });
+// 
+// If you need to pass additional values to initialize use:
+//
+// Event.addBehavior({ 'a.rollover' : MyBehavior(10, { thing : 15 }) })
+//
+// You can also use the attach() method.  If you specify extra arguments to attach they get passed to initialize.
+//
+// MyBehavior.attach(el, values, to, init);
+//
+// Finally, the rawest method is using the new constructor normally:
+// var draggable = new Draggable(element, init, vals);
+//
+// Each behaviour has a collection of all its instances in Behavior.instances
+//
+var Behavior = {
+  create: function() {
+    var parent = null, properties = $A(arguments);
+    if (Object.isFunction(properties[0]))
+      parent = properties.shift();
+
+      var behavior = function() { 
+        if (!this.initialize) {
+          var args = $A(arguments);
+
+          return function() {
+            var initArgs = [this].concat(args);
+            behavior.attach.apply(behavior, initArgs);
+          };
+        } else {
+          var args = (arguments.length == 2 && arguments[1] instanceof Array) ? 
+                      arguments[1] : Array.prototype.slice.call(arguments, 1);
+
+          this.element = $(arguments[0]);
+          this.initialize.apply(this, args);
+          behavior._bindEvents(this);
+          behavior.instances.push(this);
+        }
+      };
+
+    Object.extend(behavior, Class.Methods);
+    Object.extend(behavior, Behavior.Methods);
+    behavior.superclass = parent;
+    behavior.subclasses = [];
+    behavior.instances = [];
+
+    if (parent) {
+      var subclass = function() { };
+      subclass.prototype = parent.prototype;
+      behavior.prototype = new subclass;
+      parent.subclasses.push(behavior);
+    }
+
+    for (var i = 0; i < properties.length; i++)
+      behavior.addMethods(properties[i]);
+
+    if (!behavior.prototype.initialize)
+      behavior.prototype.initialize = Prototype.emptyFunction;
+
+    behavior.prototype.constructor = behavior;
+
+    return behavior;
+  },
+  Methods : {
+    attach : function(element) {
+      return new this(element, Array.prototype.slice.call(arguments, 1));
+    },
+    _bindEvents : function(bound) {
+      for (var member in bound) {
+        var matches = member.match(/^on(.+)/);
+        if (matches && typeof bound[member] == 'function')
+          bound.element.observe(matches[1], Event.addBehavior._wrapObserver(bound[member].bindAsEventListener(bound)));
+      }
+    }
+  }
+};
+
+
+
+Remote = Behavior.create({
+  initialize: function(options) {
+    if (this.element.nodeName == 'FORM') new Remote.Form(this.element, options);
+    else new Remote.Link(this.element, options);
+  }
+});
+
+Remote.Base = {
+  initialize : function(options) {
+    this.options = Object.extend({
+      evaluateScripts : true
+    }, options || {});
+    
+    this._bindCallbacks();
+  },
+  _makeRequest : function(options) {
+    if (options.update) new Ajax.Updater(options.update, options.url, options);
+    else new Ajax.Request(options.url, options);
+    return false;
+  },
+  _bindCallbacks: function() {
+    $w('onCreate onComplete onException onFailure onInteractive onLoading onLoaded onSuccess').each(function(cb) {
+      if (Object.isFunction(this.options[cb]))
+        this.options[cb] = this.options[cb].bind(this);
+    }.bind(this));
+  }
+}
+
+Remote.Link = Behavior.create(Remote.Base, {
+  onclick : function() {
+    var options = Object.extend({ url : this.element.href, method : 'get' }, this.options);
+    return this._makeRequest(options);
+  }
+});
+
+
+Remote.Form = Behavior.create(Remote.Base, {
+  onclick : function(e) {
+    var sourceElement = e.element();
+    
+    if (['input', 'button'].include(sourceElement.nodeName.toLowerCase()) && 
+        sourceElement.type == 'submit')
+      this._submitButton = sourceElement;
+  },
+  onsubmit : function() {
+    var options = Object.extend({
+      url : this.element.action,
+      method : this.element.method || 'get',
+      parameters : this.element.serialize({ submit: this._submitButton.name })
+    }, this.options);
+    this._submitButton = null;
+    return this._makeRequest(options);
+  }
+});
+
+Observed = Behavior.create({
+  initialize : function(callback, options) {
+    this.callback = callback.bind(this);
+    this.options = options || {};
+    this.observer = (this.element.nodeName == 'FORM') ? this._observeForm() : this._observeField();
+  },
+  stop: function() {
+    this.observer.stop();
+  },
+  _observeForm: function() {
+    return (this.options.frequency) ? new Form.Observer(this.element, this.options.frequency, this.callback) :
+                                      new Form.EventObserver(this.element, this.callback);
+  },
+  _observeField: function() {
+    return (this.options.frequency) ? new Form.Element.Observer(this.element, this.options.frequency, this.callback) :
+                                      new Form.Element.EventObserver(this.element, this.callback);
+  }
+});
+

data/public/javascripts/admin/pngfix.js

@@ -0,0 +1,39 @@
+/**
+ * Correctly handle PNG transparency in Win IE 5.5 & 6.
+ * http://homepage.ntlworld.com/bobosola. Updated 18-Jan-2006.
+ * 
+ * Use in <HEAD> with DEFER keyword wrapped in conditional comments:
+ * 
+ *   <!--[if lt IE 7]>
+ *   <script defer type="text/javascript" src="pngfix.js"></script>
+ *   <![endif]-->
+ * 
+ */
+
+var arVersion = navigator.appVersion.split("MSIE"),
+    version = parseFloat(arVersion[1]),
+    filters = false;
+    
+try { filters = !!document.body.filters }
+catch (e) {}
+
+if (version >= 5.5 && filters) {
+  $A(document.images).each(function(img) {
+    if (!img.src.toLowerCase().endsWith('png')) return;
+    
+    var span = new Element('span', { id: img.id, className: img.className, title: (img.title || img.alt) }).
+      setStyle({
+        display: 'inline-block',
+        width: img.width + 'px',
+        height: img.height + 'px',
+        filter: 'progid:DXImageTransform.Microsoft.AlphaImageLoader(src="' + img.src + '", sizingMethod="scale")'
+      }).
+      setStyle(img.style.cssText);
+    
+    if (img.align == "left")       span.setStyle("float: left");
+    else if (img.align == "right") span.setStyle("float: right");
+    if (img.parentElement.href)    span.setStyle("cursor: hand");
+    
+    $(img).replace(span);
+  });
+}

data/public/javascripts/admin/popup.js

@@ -0,0 +1,216 @@
+/*
+ *  popup.js
+ *
+ *  dependencies: prototype.js, effects.js, lowpro.js
+ *
+ *  --------------------------------------------------------------------------
+ *  
+ *  Allows you to open up a URL inside of a Facebook-style window. To use
+ *  simply assign the class "popup" to a link that contains an href to the
+ *  HTML snippet that you would like to load up inside a window:
+ *  
+ *    <a class="popup" href="window.html">Window</a>
+ *
+ *  You can also "popup" a specific div by referencing it by ID:
+ *
+ *    <a class="popup" href="#my_div">Popup</a>
+ *    <div id="my_div" style="display:none">Hello World!</div>
+ *  
+ *  You will need to install the following hook:
+ *  
+ *    Event.addBehavior({'a.popup': Popup.TriggerBehavior()});
+ *
+ *  --------------------------------------------------------------------------
+ *  
+ *  Copyright (c) 2008, John W. Long
+ *  Portions copyright (c) 2008, Five Points Solutions, Inc.
+ *  
+ *  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.
+ *  
+ */
+
+var Popup = {
+  BorderThickness: 8,
+  BorderImage: '/images/popup_border_background.png',
+  BorderTopLeftImage: '/images/popup_border_top_left.png',
+  BorderTopRightImage: '/images/popup_border_top_right.png',
+  BorderBottomLeftImage: '/images/popup_border_bottom_left.png',
+  BorderBottomRightImage: '/images/popup_border_bottom_right.png'
+};
+
+Popup.borderImages = function() {
+  return $A([
+    Popup.BorderImage,
+    Popup.BorderTopLeftImage,
+    Popup.BorderTopRightImage,
+    Popup.BorderBottomLeftImage,
+    Popup.BorderBottomRightImage
+  ]);
+}
+
+Popup.preloadImages = function() {
+  if (!Popup.imagesPreloaded) {
+    Popup.borderImages().each(function(src) {
+      var image = new Image();
+      image.src = src;
+    });
+    Popup.preloadedImages = true;
+  }
+}
+
+Popup.TriggerBehavior = Behavior.create({
+  initialize: function() {
+    var matches = this.element.href.match(/\#(.+)$/);
+    if (matches) {
+      this.window = new Popup.Window($(matches[1]));
+    } else {
+     this.window = new Popup.AjaxWindow(this.element.href);
+    }
+  },
+  
+  onclick: function(event) {
+    this.popup();
+    event.stop();
+  },
+  
+  popup: function() {
+    this.window.show();
+  }
+});
+
+Popup.AbstractWindow = Class.create({
+  initialize: function() {
+    Popup.preloadImages();
+    this.buildWindow();
+  },
+  
+  buildWindow: function() {
+    this.element = $div({'class': 'popup_window', style: 'display: none; padding: 0 ' + Popup.BorderThickness + 'px; position: absolute'});
+    
+    this.top = $div({style: 'background: url(' + Popup.BorderImage + '); height: ' + Popup.BorderThickness + 'px'});
+    this.element.insert(this.top);
+    
+    var outer = $div({style: 'background: url(' + Popup.BorderImage + '); margin: 0px -' + Popup.BorderThickness + 'px; padding: 0px ' + Popup.BorderThickness + 'px; position: relative'});
+    this.element.insert(outer);
+    
+    this.bottom = $div({style: 'background: url(' + Popup.BorderImage + '); height: ' + Popup.BorderThickness + 'px'});
+    this.element.insert(this.bottom);
+    
+    var topLeft = $div({style: 'background: url(' + Popup.BorderTopLeftImage + '); height: ' + Popup.BorderThickness + 'px; width: ' + Popup.BorderThickness + 'px; position: absolute; left: 0; top: -' + Popup.BorderThickness + 'px'});
+    outer.insert(topLeft);
+    
+    var topRight = $div({style: 'background: url(' + Popup.BorderTopRightImage + '); height: ' + Popup.BorderThickness + 'px; width: ' + Popup.BorderThickness + 'px; position: absolute; right: 0; top: -' + Popup.BorderThickness + 'px'});
+    outer.insert(topRight);
+    
+    var bottomLeft = $div({style: 'background: url(' + Popup.BorderBottomLeftImage + '); height: ' + Popup.BorderThickness + 'px; width: ' + Popup.BorderThickness + 'px; position: absolute; left: 0; bottom: -' + Popup.BorderThickness + 'px'});
+    outer.insert(bottomLeft);
+    
+    var bottomRight = $div({style: 'background: url(' + Popup.BorderBottomRightImage + '); height: ' + Popup.BorderThickness + 'px; width: ' + Popup.BorderThickness + 'px; position: absolute; right: 0; bottom: -' + Popup.BorderThickness + 'px'});
+    outer.insert(bottomRight);
+    
+    this.content = $div({style: 'background-color: white'});
+    outer.insert(this.content);
+    
+    var body = $$('body').first();
+    body.insert(this.element);
+  },
+  
+  show: function() {
+    this.beforeShow();
+    this.element.show();
+    this.afterShow();
+  },
+  
+  hide: function() {
+    this.element.hide();
+  },
+  
+  toggle: function() {
+    if (this.element.visible()) {
+      this.hide();
+    } else {
+      this.show();
+    }
+  },
+  
+  focus: function() {
+    var form = this.element.down('form');
+    if (form) {
+      var elements = form.getElements().reject(function(e) { return e.type == 'hidden' });
+      var element = elements[0] || form.down('button');
+      if (element) element.focus();
+    }
+  },
+  
+  beforeShow: function() {
+    if (Prototype.Browser.IE) {
+      // IE fixes
+      var width = this.element.getWidth() - (Popup.BorderThickness * 2);
+      this.top.setStyle("width:" + width + "px");
+      this.bottom.setStyle("width:" + width + "px");
+    }
+    this.centerWindowInView();
+  },
+  
+  afterShow: function() {
+    this.focus();
+  },
+
+  centerWindowInView: function() {
+    var offsets = document.viewport.getScrollOffsets();
+    this.element.setStyle({
+      left: parseInt(offsets.left + (document.viewport.getWidth() - this.element.getWidth()) / 2) + 'px',
+      top: parseInt(offsets.top + (document.viewport.getHeight() - this.element.getHeight()) / 2.2) + 'px'
+    });
+  }
+});
+
+Popup.Window = Class.create(Popup.AbstractWindow, {
+  initialize: function($super, element) {
+    $super();
+    element.remove();
+    this.content.update(element);
+    element.show();
+  }
+});
+
+Popup.AjaxWindow = Class.create(Popup.AbstractWindow, {
+  initialize: function($super, url, options) {
+    $super();
+    options = Object.extend({reload: true}, options);
+    this.url = url;
+    this.reload = options.reload;
+  },
+  
+  show: function($super) {
+    if (!this.loaded || this.reload) {
+      new Ajax.Updater(this.content, this.url, {asynchronous: false, method: "get", evalScripts: true, onComplete: $super});
+      this.loaded = true;
+    } else {
+      $super();
+    }
+  }
+});
+
+// Element extensions
+Element.addMethods({
+  closePopup: function(element) {
+    $(element).up('div.popup_window').hide();
+  }
+});