refinerycms 0.9.6.34 → 0.9.7

data/public/javascripts/jquery/jquery.html5-placeholder-shim.js

@@ -0,0 +1,81 @@
+(function($) {
+	$.extend($,{ placeholder: {
+			browser_supported: function() {
+				return this._supported !== undefined ?
+					this._supported :
+					( this._supported = !!('placeholder' in $('<input type="text">')[0]) );
+			},
+			shim: function(opts) {
+				var config = {
+					color: '#888',
+					cls: '',
+					lr_padding:4
+				};
+				$.extend(config,opts);
+				!this.browser_supported() && $('input[placeholder]')._placeholder_shim(config);
+			}
+	}});
+
+	$.extend($.fn,{
+		_placeholder_shim: function(config) {
+			function calcPositionCss(target)
+			{
+				var op = $(target).offsetParent().offset();
+				var ot = $(target).offset();
+
+				return {
+					top: ot.top - op.top + ($(target).outerHeight() - $(target).height()) /2,
+					left: ot.left - op.left + config.lr_padding,
+					width: $(target).width() - config.lr_padding
+				};
+			}
+			return this.each(function() {
+				if( $(this).data('placeholder') ) {
+					var $ol = $(this).data('placeholder');
+					$ol.css(calcPositionCss($(this)));
+					return true;
+				}
+
+				var ol = $('<label />')
+					.text($(this).attr('placeholder'))
+					.addClass(config.cls)
+					.css({
+						position:'absolute',
+						display: 'inline',
+						float:'none',
+						overflow:'hidden',
+						whiteSpace:'nowrap',
+						textAlign: 'left',
+						color: config.color,
+						cursor: 'text',
+						fontSize: $(this).css('font-size'),
+						lineHeight: $(this).css('height')
+					})
+					.css(calcPositionCss(this))
+					.attr('for', this.id)
+					.data('target',$(this))
+					.click(function(){
+						$(this).data('target').focus()
+					})
+					.insertBefore(this);
+				$(this)
+					.data('placeholder',ol)
+					.focus(function(){
+						ol.hide();
+					}).blur(function() {
+						ol[$(this).val().length ? 'hide' : 'show']();
+					}).triggerHandler('blur');
+				$(window)
+					.resize(function() {
+						var $target = ol.data('target')
+						ol.css(calcPositionCss($target))
+					});
+			});
+		}
+	});
+
+})(jQuery);
+
+$(document).ready(function() {
+  $.placeholder.shim();
+});

data/public/javascripts/jquery/jquery.nestedsortables.js

@@ -0,0 +1,186 @@
+$.fn.nestedSortable = function(options) {
+
+  var settings = $.extend({
+    nestable: 'li'
+    , container: 'ul'
+    , indent: 30
+    , handle: null
+    , opacity: 1
+    , placeholderClass: 'placeholder'
+    , placeholderElement: 'div'
+    , helperClass: 'helper'
+    , appendTo: 'parent'
+    , start: function() {}
+    , stop: function() {}
+    , drag: function() {}
+    , maxDepth: null
+  }, options);
+  settings.snapTolerance = settings.indent * 0.4;
+  cursor = {x: 0, y: 0};
+
+  this.each(function() {
+
+    // The top level nestable list container
+    var $root = $(this);
+
+    // An element placed to preview the location of the dragged element in its new position
+    var $placeholder = $('<' + settings.placeholderElement + '></' + settings.placeholderElement + '>', {
+      "class":  settings.placeholderClass
+    });
+
+    
+    $root.find(settings.nestable).each(function() {
+
+      var $this = $(this);
+
+      // Check if the element has already been set up as a nestable
+      if (!$this.data("nestable")) {
+
+       // Make the element draggable
+       $this.draggable({
+
+        // Transfer over some settings to jQuery's draggable implementation
+        opacity: settings.opacity,
+        handle: settings.handle,
+        appendTo: settings.appendTo,
+
+        // Creates a helper element
+        helper: function() {
+          // Create a helper that is a clone of the original (with a few little tweaks)
+          return $this.clone().width($this.width()).addClass(settings.helperClass);
+        },
+
+        // When dragging starts
+        start: function() {
+
+          // Hide the original and initialize the placeholder ontop of the starting position
+          $this.addClass('ui-dragging').hide().after($placeholder);
+
+          // Find the deepest nested child
+          var maxChildDepth = 0;
+          $this.find(settings.nestable).each(function(index, child) {
+           var $child = $(child);
+           var childDepth = $child.parentsUntil($this).filter(settings.nestable).length;
+           if (childDepth > maxChildDepth) {
+             maxChildDepth = childDepth;
+           }
+          });
+          $this.data("maxChildDepth", maxChildDepth);
+
+          // Run a custom start function specitifed in the settings
+          settings.start.apply(this);
+
+        },
+
+        // When dragging ends
+        stop: function(event, ui) {
+          // Replace the placeholder with the original while protecting it from disappearing.
+          if ($.inArray($root.get(0), $placeholder.parents()) > -1) {
+            $placeholder.after($this.show()).remove();
+          } else {
+            $this.show();
+            $placeholder.remove();
+          }
+          // Run a custom stop function specitifed in the settings
+          settings.stop.apply(this);
+          $('.ui-dragging').removeClass('ui-dragging');
+          $('.below-placeholder').removeClass('below-placeholder').animate({'marginTop':'0px'}, 0);
+        },
+
+        // Each "step" during the drag
+        drag: function (event, ui) {
+          // reduce sensitivity
+          if (cursor.y == 0 || typeof(event.clientY) == 'undefined' || ((cursor.y - event.clientY) >= 15) || ((cursor.y - event.clientY) <= -15) ) {
+            // Cycle through all nestables to find the item directly underneath the helper
+            var largestY = 0;
+            var depth;
+            var maxChildDepth = $this.data("maxChildDepth");
+            var underItems = $.grep($root.find(settings.nestable), function(item) {
+
+             $item = $(item);
+
+             // Is the item being  checked underneath the one being dragged?
+             if (!(($item.offset().top < ui.position.top) && ($item.offset().top > largestY))) {
+               return false;
+             }
+
+             // Is the item being checked on the same nesting level as the dragged item?
+             if ($item.offset().left - settings.snapTolerance >= ui.position.left) {
+               return false;
+             }
+
+             // Make sure the item being checked is not part of the helper
+             if (ui.helper.find($item).length) {
+               return false;
+             }
+
+             // Make sure the item complies with max depth rules
+             if (settings.maxDepth !== null) {
+               depth = $item.parentsUntil($root).filter(settings.container).length + maxChildDepth;
+               if (depth - 1 > settings.maxDepth) {
+                 return false;
+               }
+             }
+
+             // If we've got this far, its a match
+             largestY = $item.offset().top;
+             return true;
+
+            });
+
+            var underItem = underItems.length ? $(underItems.pop()) : null;
+            var nestedBeneath = null;
+
+            // If there is no item directly underneath the helper, check if the helper is over the first list item
+            if (underItem === null) {
+               var firstItem = $root.find(settings.nestable + ":first");
+
+               if ((firstItem.offset().top < ui.position.top + $(this).height()) && (firstItem.offset().top > ui.position.top)) {
+                 underContainer = firstItem.closest(settings.container);
+                 nestedBeneath = underContainer;
+                 underContainer.prepend($placeholder);
+               }
+
+             // Place the placeholder inside or after the item underneath, depending on their relative x coordinates
+            } else {
+              // Should the dragged item be nested?
+              if ((underItem.offset().left + settings.indent - settings.snapTolerance < ui.position.left) && (settings.maxDepth === null || depth <= settings.maxDepth)) {
+                underContainer = underItem.children(settings.container);
+                nestedBeneath = underContainer;
+                underContainer.prepend($placeholder);
+              }
+              // ... or should it just be placed after
+              else {
+                nestedBeneath = underItem;
+                underItem.after($placeholder);
+              }
+            }
+            try{
+              $placeholder.css({'width': (w = nestedBeneath.width()) > 0 ? w : $placeholder.parent().width()});
+            } catch(e) {}
+
+            old_placeholder = $('.below-placeholder').removeClass('below-placeholder');
+            new_below_placeholder = $placeholder.nextAll('li.record:not(.ui-dragging):not(.ui-draggable-dragging):first').addClass('below-placeholder');
+            if (old_placeholder.attr('id') != new_below_placeholder.attr('id')) {
+              old_placeholder.animate({'marginTop':'0px'}, 125);
+              new_below_placeholder.addClass('below-placeholder').animate({'marginTop' : '20px'}, 125);
+            }
+            // Run a custom drag callback specifed in the settings
+            settings.drag.apply(this);
+
+            // save mouse co-ordinates.
+            if (typeof(event.clientX) != 'undefined') {
+              cursor.x = event.clientX;
+            }
+            if (typeof(event.clientY) != 'undefined') {
+              cursor.y = event.clientY;
+            }
+          }
+        }
+
+       }).data("nestable", true);
+      }
+    });
+  });
+  return this;
+};

data/public/javascripts/jquery/jquery.textTruncate.js

@@ -0,0 +1,174 @@
+{ // a dummy block, so I can collapse all the meta stuff in the editor
+/****************************************************************************
+ * jQuery 1.3.x plugin to shorten styled text to fit in a block, appending
+ * an ellipsis ("...", …, Unicode: 2026) or other text.
+ * (Only supports ltr text for now.)
+ *
+ * This is achieved by placing the text of the 'selected' element (eg. span or
+ * div) inside a table and measuring its width. If it's too big to big to fit in
+ * the element's parent block it's shortened and measured again until it (and
+ * appended ellipsis or text) fits inside the block. A tooltip on the 'selected'
+ * element displays the full original text.
+ *
+ * If the browser supports truncating text using the 'text-overflow:ellipsis'
+ * CSS property then that will be used (if the text to append is the default
+ * ellipsis).
+ *
+ * If the text is truncated by the plugin any markup in the text will be
+ * stripped (eg: "<a" starts stripping, "< a" does not). This behaviour is
+ * dictated by the jQuery .text(val) method.
+ * The appended text may contain HTML however (a link or span for example).
+ *
+ * Usage Example ('selecting' a div with an id of "element"):
+
+	<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
+	<script type="text/javascript" src="jquery.textTruncate.js"></script>
+	<script type="text/javascript">
+		$(function() {
+			$("#element").textTruncate();
+		});
+	</script>
+
+ * By default the plugin will use the parent block's width as maximum width and
+ * an ellipsis as appended text when truncating.
+ *
+ * There are three ways of configuring the plugin:
+ *
+ * 1) Passing a configuration hash as the plugin's argument, eg:
+
+	.textTruncate({
+		width: 300,
+		tail: ' <a href="#">more</a>',
+		tooltip: false
+	});
+
+ * 2) Using two optional arguments (deprecated!):
+ * width = the desired pixel width, integer
+ * tail = text/html to append when truncating
+ *
+ * 3) By changing the plugin defaults, eg:
+
+	$.fn.textTruncate.defaults.tail = ' <a href="#">more</a>';
+
+ * Note: there is no default width (unless you create one).
+ *
+ * You may want to set the element's css to {visibility:hidden;} so it won't
+ * initially flash at full width.
+ *
+ *
+ * Created by M. David Green (www.mdavidgreen.com) in 2009. Free to use for
+ * personal or commercial purposes under MIT (X11) license with no warranty
+ *
+ * Heavily modified/simplified/improved by Marc Diethelm (http://web5.me/).
+ *
+****************************************************************************/
+}
+
+
+(function ($) {
+
+	$.fn.textTruncate = function() {
+
+		var userOptions = {};
+		var args = arguments; // for better minification
+		var func = args.callee // dito; and much shorter than $.fn.textTruncate
+
+		if ( args.length ) {
+
+			if ( args[0].constructor == Object ) {
+				userOptions = args[0];
+			} else if ( args[0] == "options" ) {
+				return $(this).eq(0).data("options-truncate");
+			} else {
+				userOptions = {
+					width: parseInt(args[0]),
+					tail: args[1]
+				}
+			}
+		}
+
+		this.css("visibility","hidden"); // Hide the element(s) while manipulating them
+
+		// apply options vs. defaults
+		var options = $.extend({}, func.defaults, userOptions);
+
+
+		/**
+		 * HERE WE GO!
+		 **/
+		return this.each(function () {
+
+			var $this = $(this);
+			$this.data("options-truncate", options);
+
+			/**
+			 * If browser implements text-overflow:ellipsis in CSS and tail is "...", use it!
+			 **/
+			if ( options.tail == "..." && func._native ) {
+
+				this.style[func._native] = "ellipsis";
+				/*var css_obj = {}
+				css_obj[func._native] = "ellipsis";
+				$this.css(css_obj);*/
+				$this.css("visibility","visible");
+
+				return true;
+			}
+
+			var width = options.width || $this.parent().width();
+
+			var text = $this.text();
+			var textlength = text.length;
+			var css = "padding:0; margin:0; border:none; font:inherit;";
+			var $table = $('<table style="'+ css +'width:auto;zoom:1;position:absolute;"><tr style="'+ css +'"><td style="'+ css +'white-space:nowrap;">' + options.tail + '</td></tr></table>');
+			var $td = $("td", $table);
+			$this.html( $table );
+
+			var tailwidth = $td.width();
+			var targetWidth = width - tailwidth;
+
+			$td.text( text );
+
+			if ($td.width() > width) {
+				if ( options.tooltip ) {
+					$this.attr("title", text);
+				}
+
+				while ($td.width() >= targetWidth ) {
+					textlength--;
+					$td.html($td.html().substring(0, textlength)); // .html(val) is faster than .text(val) and we already used .text(val) to strip/escape html
+				}
+
+				text = $.trim( $td.html() );
+				$this.html( text + options.tail );
+
+			} else {
+				$this.html( text );
+			}
+
+			this.style.visibility = "visible";
+
+			return true;
+		});
+
+		return true;
+
+	};
+
+	var css = document.documentElement.style;
+	var _native = false;
+
+	if ( "textOverflow" in css ) {
+		_native = "textOverflow";
+	} else if ( "OTextOverflow" in css ) {
+		_native = "OTextOverflow";
+	}
+
+	$.fn.textTruncate._native = _native;
+
+	$.fn.textTruncate.defaults = {
+		tail: "&hellip;",
+		tooltip: true
+	};
+
+})(jQuery);

data/public/javascripts/jquery/jquery.timers.js

@@ -0,0 +1,138 @@
+/**
+ * jQuery.timers - Timer abstractions for jQuery
+ * Written by Blair Mitchelmore (blair DOT mitchelmore AT gmail DOT com)
+ * Licensed under the WTFPL (http://sam.zoy.org/wtfpl/).
+ * Date: 2009/10/16
+ *
+ * @author Blair Mitchelmore
+ * @version 1.2
+ *
+ **/
+
+$.fn.extend({
+	everyTime: function(interval, label, fn, times) {
+		return this.each(function() {
+			$.timer.add(this, interval, label, fn, times);
+		});
+	},
+	oneTime: function(interval, label, fn) {
+		return this.each(function() {
+			$.timer.add(this, interval, label, fn, 1);
+		});
+	},
+	stopTime: function(label, fn) {
+		return this.each(function() {
+			$.timer.remove(this, label, fn);
+		});
+	}
+});
+
+$.extend({
+	timer: {
+		global: [],
+		guid: 1,
+		dataKey: "$.timer",
+		regex: /^([0-9]+(?:\.[0-9]*)?)\s*(.*s)?$/,
+		powers: {
+			// Yeah this is major overkill...
+			'ms': 1,
+			'cs': 10,
+			'ds': 100,
+			's': 1000,
+			'das': 10000,
+			'hs': 100000,
+			'ks': 1000000
+		},
+		timeParse: function(value) {
+			if (value == undefined || value == null)
+				return null;
+			var result = this.regex.exec($.trim(value.toString()));
+			if (result[2]) {
+				var num = parseFloat(result[1]);
+				var mult = this.powers[result[2]] || 1;
+				return num * mult;
+			} else {
+				return value;
+			}
+		},
+		add: function(element, interval, label, fn, times) {
+			var counter = 0;
+
+			if ($.isFunction(label)) {
+				if (!times)
+					times = fn;
+				fn = label;
+				label = interval;
+			}
+
+			interval = $.timer.timeParse(interval);
+
+			if (typeof interval != 'number' || isNaN(interval) || interval < 0)
+				return;
+
+			if (typeof times != 'number' || isNaN(times) || times < 0)
+				times = 0;
+
+			times = times || 0;
+
+			var timers = $.data(element, this.dataKey) || $.data(element, this.dataKey, {});
+
+			if (!timers[label])
+				timers[label] = {};
+
+			fn.timerID = fn.timerID || this.guid++;
+
+			var handler = function() {
+				if ((++counter > times && times !== 0) || fn.call(element, counter) === false)
+					$.timer.remove(element, label, fn);
+			};
+
+			handler.timerID = fn.timerID;
+
+			if (!timers[label][fn.timerID])
+				timers[label][fn.timerID] = window.setInterval(handler,interval);
+
+			this.global.push( element );
+
+		},
+		remove: function(element, label, fn) {
+			var timers = $.data(element, this.dataKey), ret;
+
+			if ( timers ) {
+
+				if (!label) {
+					for ( label in timers )
+						this.remove(element, label, fn);
+				} else if ( timers[label] ) {
+					if ( fn ) {
+						if ( fn.timerID ) {
+							window.clearInterval(timers[label][fn.timerID]);
+							delete timers[label][fn.timerID];
+						}
+					} else {
+						for ( var fn in timers[label] ) {
+							window.clearInterval(timers[label][fn]);
+							delete timers[label][fn];
+						}
+					}
+
+					for ( ret in timers[label] ) break;
+					if ( !ret ) {
+						ret = null;
+						delete timers[label];
+					}
+				}
+
+				for ( ret in timers ) break;
+				if ( !ret )
+					$.removeData(element, this.dataKey);
+			}
+		}
+	}
+});
+
+$(window).bind("unload", function() {
+	$.each($.timer.global, function(index, item) {
+		$.timer.remove(item);
+	});
+});