atreides 2.0.3 → 2.0.4

data/lib/assets/javascripts/atreides/jquery.iphone-checkboxes.js

@@ -0,0 +1,214 @@
+/*!
+// iPhone-style Checkboxes jQuery plugin
+// Copyright Thomas Reynolds, licensed GPL & MIT
+*/
+;(function($, iphoneStyle) {
+
+// Constructor
+$[iphoneStyle] = function(elem, options) {
+  this.$elem = $(elem);
+  
+  // Import options into instance variables
+  var obj = this;
+  $.each(options, function(key, value) {
+    obj[key] = value;
+  });
+  
+  // Initialize the control
+  this.wrapCheckboxWithDivs();
+  this.attachEvents();
+  this.disableTextSelection();
+  
+  if (this.resizeHandle)    { this.optionallyResize('handle'); }
+  if (this.resizeContainer) { this.optionallyResize('container'); }
+  
+  this.initialPosition();
+};
+
+$.extend($[iphoneStyle].prototype, {
+  // Wrap the existing input[type=checkbox] with divs for styling and grab DOM references to the created nodes
+  wrapCheckboxWithDivs: function() {
+    this.$elem.wrap('<div class="' + this.containerClass + '" />');
+    this.container = this.$elem.parent();
+    
+    this.offLabel  = $('<label class="'+ this.labelOffClass +'">' +
+                         '<span>'+ this.uncheckedLabel +'</span>' +
+                       '</label>').appendTo(this.container);
+    this.offSpan   = this.offLabel.children('span');
+    
+    this.onLabel   = $('<label class="'+ this.labelOnClass +'">' +
+                         '<span>'+ this.checkedLabel +'</span>' +
+                       '</label>').appendTo(this.container);
+    this.onSpan    = this.onLabel.children('span');
+    
+    this.handle    = $('<div class="' + this.handleClass + '">' +
+                         '<div class="' + this.handleRightClass + '">' +
+                           '<div class="' + this.handleCenterClass + '" />' +
+                         '</div>' +
+                       '</div>').appendTo(this.container);
+  },
+  
+  // Disable IE text selection, other browsers are handled in CSS
+  disableTextSelection: function() {
+    if (!$.browser.msie) { return; }
+
+    // Elements containing text should be unselectable
+    $.each([this.handle, this.offLabel, this.onLabel, this.container], function(el) {
+      $(el).attr("unselectable", "on");
+    });
+  },
+  
+  // Automatically resize the handle or container
+  optionallyResize: function(mode) {
+    var onLabelWidth  = this.onLabel.width(),
+        offLabelWidth = this.offLabel.width(),
+        newWidth      = (onLabelWidth < offLabelWidth) ? onLabelWidth : offLabelWidth;
+
+    if (mode == 'container') { newWidth += this.handle.width() + 15; }
+    this[mode].css({ width: newWidth });
+  },
+  
+  attachEvents: function() {
+    var obj = this;
+    
+    // A mousedown anywhere in the control will start tracking for dragging
+    this.container
+      .bind('mousedown touchstart', function(event) {          
+        event.preventDefault();
+        
+        if (obj.$elem.is(':disabled')) { return; }
+          
+        var x = event.pageX || event.originalEvent.changedTouches[0].pageX;
+        $[iphoneStyle].currentlyClicking = obj.handle;
+        $[iphoneStyle].dragStartPosition = x - (parseInt(obj.handle.css('left'), 10) || 0);
+      })
+    
+      // Utilize event bubbling to handle drag on any element beneath the container
+      .bind('iPhoneDrag', function(event, x) {
+        event.preventDefault();
+        
+        if (obj.$elem.is(':disabled')) { return; }
+        
+        var p = (x - $[iphoneStyle].dragStartPosition) / obj.rightSide;
+        if (p < 0) { p = 0; }
+        if (p > 1) { p = 1; }
+      
+        obj.handle.css({ left: p * obj.rightSide });
+        obj.onLabel.css({ width: p * obj.rightSide + 4 });
+        obj.offSpan.css({ marginRight: -p * obj.rightSide });
+        obj.onSpan.css({ marginLeft: -(1 - p) * obj.rightSide });
+      })
+    
+        // Utilize event bubbling to handle drag end on any element beneath the container
+      .bind('iPhoneDragEnd', function(event, x) {
+        if (obj.$elem.is(':disabled')) { return; }
+        
+        if ($[iphoneStyle].dragging) {
+          var p = (x - $[iphoneStyle].dragStartPosition) / obj.rightSide;
+          obj.$elem.attr('checked', (p >= 0.5));
+        } else {
+          obj.$elem.attr('checked', !obj.$elem.attr('checked'));
+        }
+
+        $[iphoneStyle].currentlyClicking = null;
+        $[iphoneStyle].dragging = null;
+        obj.$elem.change();
+      });
+  
+    // Animate when we get a change event
+    this.$elem.change(function() {
+      if (obj.$elem.is(':disabled')) {
+        obj.container.addClass(obj.disabledClass);
+        return false;
+      } else {
+        obj.container.removeClass(obj.disabledClass);
+      }
+      
+      var new_left = obj.$elem.attr('checked') ? obj.rightSide : 0;
+
+      obj.handle.animate({         left: new_left },                 obj.duration);
+      obj.onLabel.animate({       width: new_left + 4 },             obj.duration);
+      obj.offSpan.animate({ marginRight: -new_left },                obj.duration);
+      obj.onSpan.animate({   marginLeft: new_left - obj.rightSide }, obj.duration);
+    });
+  },
+  
+  // Setup the control's inital position
+  initialPosition: function() {
+    this.offLabel.css({ width: this.container.width() - 5 });
+
+    var offset = ($.browser.msie && $.browser.version < 7) ? 3 : 6;
+    this.rightSide = this.container.width() - this.handle.width() - offset;
+
+    if (this.$elem.is(':checked')) {
+      this.handle.css({ left: this.rightSide });
+      this.onLabel.css({ width: this.rightSide + 4 });
+      this.offSpan.css({ marginRight: -this.rightSide });
+    } else {
+      this.onLabel.css({ width: 0 });
+      this.onSpan.css({ marginLeft: -this.rightSide });
+    }
+    
+    if (this.$elem.is(':disabled')) {
+      this.container.addClass(this.disabledClass);
+    }
+  }
+});
+
+// jQuery-specific code
+$.fn[iphoneStyle] = function(options) {
+  var checkboxes = this.filter(':checkbox');
+  
+  // Fail early if we don't have any checkboxes passed in
+  if (!checkboxes.length) { return this; }
+  
+  // Merge options passed in with global defaults
+  var opt = $.extend({}, $[iphoneStyle].defaults, options);
+  
+  checkboxes.each(function() {
+    $(this).data(iphoneStyle, new $[iphoneStyle](this, opt));
+  });
+
+  if (!$[iphoneStyle].initComplete) {
+    // As the mouse moves on the page, animate if we are in a drag state
+    $(document)
+      .bind('mousemove touchmove', function(event) {
+        if (!$[iphoneStyle].currentlyClicking) { return; }
+        if (event.pageX != $[iphoneStyle].dragStartPosition) { $[iphoneStyle].dragging = true; }
+        event.preventDefault();
+    
+        var x = event.pageX || event.originalEvent.changedTouches[0].pageX;
+        $(event.target).trigger('iPhoneDrag', [x]);
+      })
+
+      // When the mouse comes up, leave drag state
+      .bind('mouseup touchend', function(event) {        
+        if (!$[iphoneStyle].currentlyClicking) { return; }
+        event.preventDefault();
+    
+        var x = event.pageX || event.originalEvent.changedTouches[0].pageX;
+        $($[iphoneStyle].currentlyClicking).trigger('iPhoneDragEnd', [x]);
+      });
+      
+    $[iphoneStyle].initComplete = true;
+  }
+  
+  return this;
+}; // End of $.fn[iphoneStyle]
+
+$[iphoneStyle].defaults = {
+  duration:          200,                       // Time spent during slide animation
+  checkedLabel:      'ON',                      // Text content of "on" state
+  uncheckedLabel:    'OFF',                     // Text content of "off" state
+  resizeHandle:      true,                      // Automatically resize the handle to cover either label
+  resizeContainer:   true,                      // Automatically resize the widget to contain the labels
+  disabledClass:     'iPhoneCheckDisabled',
+  containerClass:    'iPhoneCheckContainer',
+  labelOnClass:      'iPhoneCheckLabelOn',
+  labelOffClass:     'iPhoneCheckLabelOff',
+  handleClass:       'iPhoneCheckHandle',
+  handleCenterClass: 'iPhoneCheckHandleCenter',
+  handleRightClass:  'iPhoneCheckHandleRight'
+};
+
+})(jQuery, 'iphoneStyle');

data/lib/assets/javascripts/atreides/jquery.jBreadCrumb.1.1.js

@@ -0,0 +1,240 @@
+/**
+ * @author Jason Roy for CompareNetworks Inc.
+ * Thanks to mikejbond for suggested udaptes
+ *
+ * Version 1.1
+ * Copyright (c) 2009 CompareNetworks Inc.
+ *
+ * Licensed under the MIT license:
+ * http://www.opensource.org/licenses/mit-license.php
+ *
+ */
+(function($)
+{
+
+    // Private variables
+    
+    var _options = {};
+    var _container = {};
+    var _breadCrumbElements = {};
+    var _autoIntervalArray = [];
+	var _easingEquation;
+    
+    // Public functions
+    
+    jQuery.fn.jBreadCrumb = function(options)
+    {
+        _options = $.extend({}, $.fn.jBreadCrumb.defaults, options);
+        
+        return this.each(function()
+        {
+            _container = $(this);
+            setupBreadCrumb();
+        });
+        
+    };
+    
+    // Private functions
+    
+    function setupBreadCrumb()
+    {
+		//Check if easing plugin exists. If it doesn't, use "swing"
+		if(typeof(jQuery.easing) == 'object')
+		{
+			_easingEquation = 'easeOutQuad'
+		}
+		else
+		{
+			_easingEquation = 'swing'
+		}
+    
+        //The reference object containing all of the breadcrumb elements
+        _breadCrumbElements = jQuery(_container).find('li');
+        
+        //Keep it from overflowing in ie6 & 7
+        jQuery(_container).find('ul').wrap('<div style="overflow:hidden; position:relative;  width: ' + jQuery(_container).css("width") + ';"><div>');
+        //Set an arbitrary width width to avoid float drop on the animation
+        jQuery(_container).find('ul').width(5000);
+        
+        //If the breadcrumb contains nothing, don't do anything
+        if (_breadCrumbElements.length > 0) 
+        {
+            jQuery(_breadCrumbElements[_breadCrumbElements.length - 1]).addClass('last');
+            jQuery(_breadCrumbElements[0]).addClass('first');
+            
+            //If the breadcrumb object length is long enough, compress.
+            
+            if (_breadCrumbElements.length > _options.minimumCompressionElements) 
+            {
+                compressBreadCrumb();
+            };
+                    };
+            };
+    
+    function compressBreadCrumb()
+    {
+    
+        // Factor to determine if we should compress the element at all
+        var finalElement = jQuery(_breadCrumbElements[_breadCrumbElements.length - 1]);
+        
+        
+        // If the final element is really long, compress more elements
+        if (jQuery(finalElement).width() > _options.maxFinalElementLength) 
+        {
+            if (_options.beginingElementsToLeaveOpen > 0) 
+            {
+                _options.beginingElementsToLeaveOpen--;
+                
+            }
+            if (_options.endElementsToLeaveOpen > 0) 
+            {
+                _options.endElementsToLeaveOpen--;
+            }
+        }
+        // If the final element is within the short and long range, compress to the default end elements and 1 less beginning elements
+        if (jQuery(finalElement).width() < _options.maxFinalElementLength && jQuery(finalElement).width() > _options.minFinalElementLength) 
+        {
+            if (_options.beginingElementsToLeaveOpen > 0) 
+            {
+                _options.beginingElementsToLeaveOpen--;
+                
+            }
+        }
+        
+        var itemsToRemove = _breadCrumbElements.length - 1 - _options.endElementsToLeaveOpen;
+        
+        // We compress only elements determined by the formula setting below
+        
+        //TODO : Make this smarter, it's only checking the final elements length.  It could also check the amount of elements.
+        jQuery(_breadCrumbElements[_breadCrumbElements.length - 1]).css(
+        {
+            background: 'none'
+        });
+        
+        $(_breadCrumbElements).each(function(i, listElement)
+        {
+            if (i > _options.beginingElementsToLeaveOpen && i < itemsToRemove) 
+            {
+            
+                jQuery(listElement).find('a').wrap('<span></span>').width(jQuery(listElement).find('a').width() + 10);
+                
+                // Add the overlay png.
+                jQuery(listElement).append(jQuery('<div class="' + _options.overlayClass + '"></div>').css(
+                {
+                    display: 'block'
+                })).css(
+                {
+                    background: 'none'
+                });
+                if (isIE6OrLess()) 
+                {
+                    fixPNG(jQuery(listElement).find('.' + _options.overlayClass).css(
+                    {
+                        width: '20px',
+                        right: "-1px"
+                    }));
+                }
+                var options = 
+                {
+                    id: i,
+                    width: jQuery(listElement).width(),
+                    listElement: jQuery(listElement).find('span'),
+                    isAnimating: false,
+                    element: jQuery(listElement).find('span')
+                
+                };
+                jQuery(listElement).bind('mouseover', options, expandBreadCrumb).bind('mouseout', options, shrinkBreadCrumb);
+                jQuery(listElement).find('a').unbind('mouseover', expandBreadCrumb).unbind('mouseout', shrinkBreadCrumb);
+                listElement.autoInterval = setInterval(function()
+                {
+                    clearInterval(listElement.autoInterval);
+                    jQuery(listElement).find('span').animate(
+                    {
+                        width: _options.previewWidth
+                    }, _options.timeInitialCollapse, _options.easing);
+                }, (150 * (i - 2)));
+                
+            }
+        });
+        
+    };
+    
+    function expandBreadCrumb(e)
+    {
+        var elementID = e.data.id;
+        var originalWidth = e.data.width;
+        jQuery(e.data.element).stop();
+        jQuery(e.data.element).animate(
+        {
+            width: originalWidth
+        }, 
+        {
+            duration: _options.timeExpansionAnimation,
+            easing: _options.easing,
+            queue: false
+        });
+        return false;
+        
+    };
+    
+    function shrinkBreadCrumb(e)
+    {
+        var elementID = e.data.id;
+        jQuery(e.data.element).stop();
+        jQuery(e.data.element).animate(
+        {
+            width: _options.previewWidth
+        }, 
+        {
+            duration: _options.timeCompressionAnimation,
+            easing: _options.easing,
+            queue: false
+        });
+        return false;
+    };
+    
+    function isIE6OrLess()
+    {
+        var isIE6 = $.browser.msie && /MSIE\s(5\.5|6\.)/.test(navigator.userAgent);
+        return isIE6;
+    };
+    // Fix The Overlay for IE6
+    function fixPNG(element)
+    {
+        var image;
+        if (jQuery(element).is('img')) 
+        {
+            image = jQuery(element).attr('src');
+        }
+        else 
+        {
+            image = $(element).css('backgroundImage');
+            image.match(/^url\(["']?(.*\.png)["']?\)$/i);
+            image = RegExp.$1;
+            ;
+        }
+        $(element).css(
+        {
+            'backgroundImage': 'none',
+            'filter': "progid:DXImageTransform.Microsoft.AlphaImageLoader(enabled=true, sizingMethod=scale, src='" + image + "')"
+        });
+    };
+    
+    // Public global variables
+    
+    jQuery.fn.jBreadCrumb.defaults = 
+    {
+        maxFinalElementLength: 400,
+        minFinalElementLength: 200,
+        minimumCompressionElements: 4,
+        endElementsToLeaveOpen: 1,
+        beginingElementsToLeaveOpen: 1,
+        timeExpansionAnimation: 800,
+        timeCompressionAnimation: 500,
+        timeInitialCollapse: 600,
+        easing: _easingEquation,
+        overlayClass: 'chevronOverlay',
+        previewWidth: 5
+    };
+    
+})(jQuery);