uniformjs-rails 1.5.0.2 → 3.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ac1d3201d2fc9c372b3997eb5e9417c150626597
+  data.tar.gz: 5774425401a2388c4827463bb4e11388ea5e7405
+SHA512:
+  metadata.gz: 268f13f54c2330aa30a3e88771ca3bfd49553509af688e8dbcfe9be581baaf7dd3ea84b068e574db46a1073b396bd454cf865fdef23f1a615fe4b4bf90466ca8
+  data.tar.gz: 590ae294b4b89033a6d72373ea7f3b186de39d952e2d266cd919bdbab1332f800b83596a2ff6c7549741410931ecf49ae6a7b4831bdc18c09fd4607b7cdaae04

data/lib/uniformjs-rails/version.rb

@@ -1,5 +1,5 @@
 module Uniformjs
   module Rails
-    VERSION = '1.5.0.2'
+    VERSION = '3.0.1'
   end
 end

data/vendor/assets/javascripts/jquery.uniform.js

@@ -1,672 +1,1030 @@
-/*
-
-Uniform v1.7.5
-Copyright © 2009 Josh Pyles / Pixelmatrix Design LLC
-http://pixelmatrixdesign.com
-
-Requires jQuery 1.4 or newer
-
-Much thanks to Thomas Reynolds and Buck Wilson for their help and advice on this
-
-Disabling text selection is made possible by Mathias Bynens <http://mathiasbynens.be/>
-and his noSelect plugin. <http://github.com/mathiasbynens/noSelect-jQuery-Plugin>
-
-Also, thanks to David Kaneda and Eugene Bond for their contributions to the plugin
-
-License:
-MIT License - http://www.opensource.org/licenses/mit-license.php
-
-Enjoy!
-
-*/
-
-(function($) {
-  $.uniform = {
-    options: {
-      selectClass:   'selector',
-      radioClass: 'radio',
-      checkboxClass: 'checker',
-      fileClass: 'uploader',
-      filenameClass: 'filename',
-      fileBtnClass: 'action',
-      fileDefaultText: 'No file selected',
-      fileBtnText: 'Choose File',
-      checkedClass: 'checked',
-      focusClass: 'focus',
-      disabledClass: 'disabled',
-      buttonClass: 'button',
-      activeClass: 'active',
-      hoverClass: 'hover',
-      useID: true,
-      idPrefix: 'uniform',
-      resetSelector: false,
-      autoHide: true
-    },
-    elements: []
-  };
-
-  if($.browser.msie && $.browser.version < 7){
-    $.support.selectOpacity = false;
-  }else{
-    $.support.selectOpacity = true;
-  }
-
-  $.fn.uniform = function(options) {
-
-    options = $.extend($.uniform.options, options);
-
-    var el = this;
-    //code for specifying a reset button
-    if(options.resetSelector != false){
-      $(options.resetSelector).mouseup(function(){
-        function resetThis(){
-          $.uniform.update(el);
+/**
+ * Uniform
+ * A jQuery plugin to make your form controls look how you want them to.
+ *
+ * @author Josh Pyles <joshpyles@gmail.com>
+ * @author Tyler Akins <fidian@rumkin.com>
+ * @author Shahriyar Imanov <shehi@imanov.me>
+ *
+ * @license MIT
+ *
+ * @see http://opensource.audith.org/uniform
+ */
+
+(function (wind, $, undef) {
+    "use strict";
+
+    /**
+     * Use .prop() if jQuery supports it, otherwise fall back to .attr()
+     * @usage All other parameters are passed to jQuery's function
+     *
+     * @param {jQuery} $el jQuery'd element on which we're calling attr/prop
+     * @return {*} The result from jQuery
+     */
+    function attrOrProp($el /* , args */) {
+        var args = Array.prototype.slice.call(arguments, 1);
+
+        if ($el.prop) {
+            // jQuery 1.6+
+            return $el.prop.apply($el, args);
         }
-        setTimeout(resetThis, 10);
-      });
-    }
-    
-    function doInput(elem){
-      $el = $(elem);
-      $el.addClass($el.attr("type"));
-      storeElement(elem);
-    }
-    
-    function doTextarea(elem){
-      $(elem).addClass("uniform");
-      storeElement(elem);
+
+        // jQuery 1.5 and below
+        return $el.attr.apply($el, args);
     }
-    
-    function doButton(elem){
-      var $el = $(elem);
-      
-      var divTag = $("<div>"),
-          spanTag = $("<span>");
-      
-      divTag.addClass(options.buttonClass);
-      
-      if(options.useID && $el.attr("id") != "") divTag.attr("id", options.idPrefix+"-"+$el.attr("id"));
-      
-      var btnText;
-      
-      if($el.is("a") || $el.is("button")){
-        btnText = $el.text();
-      }else if($el.is(":submit") || $el.is(":reset") || $el.is("input[type=button]")){
-        btnText = $el.attr("value");
-      }
-      
-      btnText = btnText == "" ? $el.is(":reset") ? "Reset" : "Submit" : btnText;
-      
-      spanTag.html(btnText);
-      
-      $el.css("opacity", 0);
-      $el.wrap(divTag);
-      $el.wrap(spanTag);
-      
-      //redefine variables
-      divTag = $el.closest("div");
-      spanTag = $el.closest("span");
-      
-      if($el.is(":disabled")) divTag.addClass(options.disabledClass);
-      
-      divTag.bind({
-        "mouseenter.uniform": function(){
-          divTag.addClass(options.hoverClass);
-        },
-        "mouseleave.uniform": function(){
-          divTag.removeClass(options.hoverClass);
-          divTag.removeClass(options.activeClass);
-        },
-        "mousedown.uniform touchbegin.uniform": function(){
-          divTag.addClass(options.activeClass);
-        },
-        "mouseup.uniform touchend.uniform": function(){
-          divTag.removeClass(options.activeClass);
-        },
-        "click.uniform touchend.uniform": function(e){
-          if($(e.target).is("span") || $(e.target).is("div")){    
-            if(elem[0].dispatchEvent){
-              var ev = document.createEvent('MouseEvents');
-              ev.initEvent( 'click', true, true );
-              elem[0].dispatchEvent(ev);
-            }else{
-              elem[0].click();
+
+    /**
+     * For backwards compatibility with older jQuery libraries, only bind
+     * one thing at a time.  Also, this function adds our namespace to
+     * events in one consistent location, shrinking the minified code.
+     *
+     * The properties on the events object are the names of the events
+     * that we are supposed to add to.  It can be a space separated list.
+     * The namespace will be added automatically.
+     *
+     * @param {jQuery} $el
+     * @param {Object} options Uniform options for this element
+     * @param {Object} events Events to bind, properties are event names
+     */
+    function bindMany($el, options, events) {
+        var name, namespaced;
+
+        for (name in events) {
+            if (events.hasOwnProperty(name)) {
+                namespaced = name.replace(/ |$/g, options.eventNamespace);
+                $el.bind(namespaced, events[name]);
             }
-          }
         }
-      });
-      
-      elem.bind({
-        "focus.uniform": function(){
-          divTag.addClass(options.focusClass);
-        },
-        "blur.uniform": function(){
-          divTag.removeClass(options.focusClass);
+    }
+
+    /**
+     * Bind the hover, active, focus, and blur UI updates
+     *
+     * @param {jQuery} $el Original element
+     * @param {jQuery} $target Target for the events (our div/span)
+     * @param {Object} options Uniform options for the element $target
+     */
+    function bindUi($el, $target, options) {
+        bindMany($el, options, {
+            focus: function () {
+                $target.addClass(options.focusClass);
+            },
+            blur: function () {
+                $target.removeClass(options.focusClass);
+                $target.removeClass(options.activeClass);
+            },
+            mouseenter: function () {
+                $target.addClass(options.hoverClass);
+            },
+            mouseleave: function () {
+                $target.removeClass(options.hoverClass);
+                $target.removeClass(options.activeClass);
+            },
+            "mousedown touchbegin": function () {
+                if (!$el.is(":disabled")) {
+                    $target.addClass(options.activeClass);
+                }
+            },
+            "mouseup touchend": function () {
+                $target.removeClass(options.activeClass);
+            }
+        });
+    }
+
+    /**
+     * Remove the hover, focus, active classes.
+     *
+     * @param {jQuery} $el Element with classes
+     * @param {Object} options Uniform options for the element
+     */
+    function classClearStandard($el, options) {
+        $el.removeClass(options.hoverClass + " " + options.focusClass + " " + options.activeClass);
+    }
+
+    /**
+     * Add or remove a class, depending on if it's "enabled"
+     *
+     * @param {jQuery} $el Element that has the class added/removed
+     * @param {String} className Class or classes to add/remove
+     * @param {Boolean} enabled True to add the class, false to remove
+     */
+    function classUpdate($el, className, enabled) {
+        if (enabled) {
+            $el.addClass(className);
+        } else {
+            $el.removeClass(className);
         }
-      });
-      
-      $.uniform.noSelect(divTag);
-      storeElement(elem);
-      
     }
 
-    function doSelect(elem){
-      var $el = $(elem);
-      
-      var divTag = $('<div />'),
-          spanTag = $('<span />');
-      
-      if(!$el.css("display") == "none" && options.autoHide){
-        divTag.hide();
-      }
-
-      divTag.addClass(options.selectClass);
-
-      if(options.useID && elem.attr("id") != ""){
-        divTag.attr("id", options.idPrefix+"-"+elem.attr("id"));
-      }
-      
-      var selected = elem.find(":selected:first");
-      if(selected.length == 0){
-        selected = elem.find("option:first");
-      }
-      spanTag.html(selected.html());
-      
-      elem.css('opacity', 0);
-      elem.wrap(divTag);
-      elem.before(spanTag);
-
-      //redefine variables
-      divTag = elem.parent("div");
-      spanTag = elem.siblings("span");
-
-      elem.bind({
-        "change.uniform": function() {
-          spanTag.text(elem.find(":selected").html());
-          divTag.removeClass(options.activeClass);
-        },
-        "focus.uniform": function() {
-          divTag.addClass(options.focusClass);
-        },
-        "blur.uniform": function() {
-          divTag.removeClass(options.focusClass);
-          divTag.removeClass(options.activeClass);
-        },
-        "mousedown.uniform touchbegin.uniform": function() {
-          divTag.addClass(options.activeClass);
-        },
-        "mouseup.uniform touchend.uniform": function() {
-          divTag.removeClass(options.activeClass);
-        },
-        "click.uniform touchend.uniform": function(){
-          divTag.removeClass(options.activeClass);
-        },
-        "mouseenter.uniform": function() {
-          divTag.addClass(options.hoverClass);
-        },
-        "mouseleave.uniform": function() {
-          divTag.removeClass(options.hoverClass);
-          divTag.removeClass(options.activeClass);
-        },
-        "keyup.uniform": function(){
-          spanTag.text(elem.find(":selected").html());
+    /**
+     * Updating the "checked" property can be a little tricky.  This
+     * changed in jQuery 1.6 and now we can pass booleans to .prop().
+     * Prior to that, one either adds an attribute ("checked=checked") or
+     * removes the attribute.
+     *
+     * @param {jQuery} $tag Our Uniform span/div
+     * @param {jQuery} $el Original form element
+     * @param {Object} options Uniform options for this element
+     */
+    function classUpdateChecked($tag, $el, options) {
+        var c = "checked",
+            isChecked = $el.is(":" + c);
+
+        if ($el.prop) {
+            // jQuery 1.6+
+            $el.prop(c, isChecked);
+        } else {
+            // jQuery 1.5 and below
+            if (isChecked) {
+                $el.attr(c, c);
+            } else {
+                $el.removeAttr(c);
+            }
         }
-      });
-      
-      //handle disabled state
-      if($(elem).attr("disabled")){
-        //box is checked by default, check our box
-        divTag.addClass(options.disabledClass);
-      }
-      $.uniform.noSelect(spanTag);
-      
-      storeElement(elem);
 
+        classUpdate($tag, options.checkedClass, isChecked);
     }
 
-    function doCheckbox(elem){
-      var $el = $(elem);
-      
-      var divTag = $('<div />'),
-          spanTag = $('<span />');
-      
-      if(!$el.css("display") == "none" && options.autoHide){
-        divTag.hide();
-      }
-      
-      divTag.addClass(options.checkboxClass);
-
-      //assign the id of the element
-      if(options.useID && elem.attr("id") != ""){
-        divTag.attr("id", options.idPrefix+"-"+elem.attr("id"));
-      }
-
-      //wrap with the proper elements
-      $(elem).wrap(divTag);
-      $(elem).wrap(spanTag);
-
-      //redefine variables
-      spanTag = elem.parent();
-      divTag = spanTag.parent();
-
-      //hide normal input and add focus classes
-      $(elem)
-      .css("opacity", 0)
-      .bind({
-        "focus.uniform": function(){
-          divTag.addClass(options.focusClass);
-        },
-        "blur.uniform": function(){
-          divTag.removeClass(options.focusClass);
-        },
-        "click.uniform touchend.uniform": function(){
-          if(!$(elem).attr("checked")){
-            //box was just unchecked, uncheck span
-            spanTag.removeClass(options.checkedClass);
-          }else{
-            //box was just checked, check span.
-            spanTag.addClass(options.checkedClass);
-          }
-        },
-        "mousedown.uniform touchbegin.uniform": function() {
-          divTag.addClass(options.activeClass);
-        },
-        "mouseup.uniform touchend.uniform": function() {
-          divTag.removeClass(options.activeClass);
-        },
-        "mouseenter.uniform": function() {
-          divTag.addClass(options.hoverClass);
-        },
-        "mouseleave.uniform": function() {
-          divTag.removeClass(options.hoverClass);
-          divTag.removeClass(options.activeClass);
+    /**
+     * Set or remove the "disabled" class for disabled elements, based on
+     * if the element is detected to be disabled.
+     *
+     * @param {jQuery} $tag Our Uniform span/div
+     * @param {jQuery} $el Original form element
+     * @param {Object} options Uniform options for this element
+     */
+    function classUpdateDisabled($tag, $el, options) {
+        classUpdate($tag, options.disabledClass, $el.is(":disabled"));
+    }
+
+    /**
+     * Wrap an element inside of a container or put the container next
+     * to the element.  See the code for examples of the different methods.
+     *
+     * Returns the container that was added to the HTML.
+     *
+     * @param {jQuery} $el Element to wrap
+     * @param {jQuery} $container Add this new container around/near $el
+     * @param {String} method One of "after", "before" or "wrap"
+     * @return {jQuery} $container after it has been cloned for adding to $el
+     */
+    function divSpanWrap($el, $container, method) {
+        switch (method) {
+            case "after":
+                // Result:  <element /> <container />
+                $el.after($container);
+                return $el.next();
+            case "before":
+                // Result:  <container /> <element />
+                $el.before($container);
+                return $el.prev();
+            case "wrap":
+                // Result:  <container> <element /> </container>
+                $el.wrap($container);
+                return $el.parent();
         }
-      });
-      
-      //handle defaults
-      if($(elem).attr("checked")){
-        //box is checked by default, check our box
-        spanTag.addClass(options.checkedClass);
-      }
-
-      //handle disabled state
-      if($(elem).attr("disabled")){
-        //box is checked by default, check our box
-        divTag.addClass(options.disabledClass);
-      }
-
-      storeElement(elem);
+
+        return null;
     }
 
-    function doRadio(elem){
-      var $el = $(elem);
-      
-      var divTag = $('<div />'),
-          spanTag = $('<span />');
-          
-      if(!$el.css("display") == "none" && options.autoHide){
-        divTag.hide();
-      }
-
-      divTag.addClass(options.radioClass);
-
-      if(options.useID && elem.attr("id") != ""){
-        divTag.attr("id", options.idPrefix+"-"+elem.attr("id"));
-      }
-
-      //wrap with the proper elements
-      $(elem).wrap(divTag);
-      $(elem).wrap(spanTag);
-
-      //redefine variables
-      spanTag = elem.parent();
-      divTag = spanTag.parent();
-
-      //hide normal input and add focus classes
-      $(elem)
-      .css("opacity", 0)
-      .bind({
-        "focus.uniform": function(){
-          divTag.addClass(options.focusClass);
-        },
-        "blur.uniform": function(){
-          divTag.removeClass(options.focusClass);
-        },
-        "click.uniform touchend.uniform": function(){
-          if(!$(elem).attr("checked")){
-            //box was just unchecked, uncheck span
-            spanTag.removeClass(options.checkedClass);
-          }else{
-            //box was just checked, check span
-            var classes = options.radioClass.split(" ")[0];
-            $("." + classes + " span." + options.checkedClass + ":has([name='" + $(elem).attr('name') + "'])").removeClass(options.checkedClass);
-            spanTag.addClass(options.checkedClass);
-          }
-        },
-        "mousedown.uniform touchend.uniform": function() {
-          if(!$(elem).is(":disabled")){
-            divTag.addClass(options.activeClass);
-          }
-        },
-        "mouseup.uniform touchbegin.uniform": function() {
-          divTag.removeClass(options.activeClass);
-        },
-        "mouseenter.uniform touchend.uniform": function() {
-          divTag.addClass(options.hoverClass);
-        },
-        "mouseleave.uniform": function() {
-          divTag.removeClass(options.hoverClass);
-          divTag.removeClass(options.activeClass);
+    /**
+     * Create a div/span combo for uniforming an element
+     *
+     * @param {jQuery} $el Element to wrap
+     * @param {Object} options Options for the element, set by the user
+     * @param {Object} divSpanConfig Options for how we wrap the div/span
+     * @return {Object} Contains the div and span as properties
+     */
+    function divSpan($el, options, divSpanConfig) {
+        var $div, $span, id;
+
+        if (!divSpanConfig) {
+            divSpanConfig = {};
         }
-      });
 
-      //handle defaults
-      if($(elem).attr("checked")){
-        //box is checked by default, check span
-        spanTag.addClass(options.checkedClass);
-      }
-      //handle disabled state
-      if($(elem).attr("disabled")){
-        //box is checked by default, check our box
-        divTag.addClass(options.disabledClass);
-      }
+        divSpanConfig = $.extend({
+            bind: {},
+            divClass: null,
+            divWrap: "wrap",
+            spanClass: null,
+            spanHtml: null,
+            spanWrap: "wrap"
+        }, divSpanConfig);
+
+        $div = $('<div />');
+        $span = $('<span />');
+
+        // Automatically hide this div/span if the element is hidden.
+        // Do not hide if the element is hidden because a parent is hidden.
+        if (options.autoHide && $el.is(':hidden') && $el.css('display') === 'none') {
+            $div.hide();
+        }
 
-      storeElement(elem);
+        if (divSpanConfig.divClass) {
+            $div.addClass(divSpanConfig.divClass);
+        }
+
+        if (options.wrapperClass) {
+            $div.addClass(options.wrapperClass);
+        }
+
+        if (divSpanConfig.spanClass) {
+            $span.addClass(divSpanConfig.spanClass);
+        }
+
+        id = attrOrProp($el, 'id');
+
+        if (options.useID && id) {
+            attrOrProp($div, 'id', options.idPrefix + '-' + id);
+        }
 
+        if (divSpanConfig.spanHtml) {
+            $span.html(divSpanConfig.spanHtml);
+        }
+
+        $div = divSpanWrap($el, $div, divSpanConfig.divWrap);
+        $span = divSpanWrap($el, $span, divSpanConfig.spanWrap);
+        classUpdateDisabled($div, $el, options);
+        return {
+            div: $div,
+            span: $span
+        };
     }
 
-    function doFile(elem){
-      //sanitize input
-      var $el = $(elem);
-
-      var divTag = $('<div />'),
-          filenameTag = $('<span>'+options.fileDefaultText+'</span>'),
-          btnTag = $('<span>'+options.fileBtnText+'</span>');
-      
-      if(!$el.css("display") == "none" && options.autoHide){
-        divTag.hide();
-      }
-
-      divTag.addClass(options.fileClass);
-      filenameTag.addClass(options.filenameClass);
-      btnTag.addClass(options.fileBtnClass);
-
-      if(options.useID && $el.attr("id") != ""){
-        divTag.attr("id", options.idPrefix+"-"+$el.attr("id"));
-      }
-
-      //wrap with the proper elements
-      $el.wrap(divTag);
-      $el.after(btnTag);
-      $el.after(filenameTag);
-
-      //redefine variables
-      divTag = $el.closest("div");
-      filenameTag = $el.siblings("."+options.filenameClass);
-      btnTag = $el.siblings("."+options.fileBtnClass);
-
-      //set the size
-      if(!$el.attr("size")){
-        var divWidth = divTag.width();
-        //$el.css("width", divWidth);
-        $el.attr("size", divWidth/10);
-      }
-
-      //actions
-      var setFilename = function()
-      {
-        var filename = $el.val();
-        if (filename === '')
-        {
-          filename = options.fileDefaultText;
+    /**
+     * Wrap an element with a span to apply a global wrapper class
+     *
+     * @param {jQuery} $el Element to wrap
+     * @param {Object} options
+     * @return {jQuery} jQuery Wrapper element
+     */
+    function wrapWithWrapperClass($el, options) {
+        var $span;
+
+        if (!options.wrapperClass) {
+            return null;
         }
-        else
-        {
-          filename = filename.split(/[\/\\]+/);
-          filename = filename[(filename.length-1)];
+
+        $span = $('<span />').addClass(options.wrapperClass);
+        $span = divSpanWrap($el, $span, "wrap");
+        return $span;
+    }
+
+    /**
+     * Test if high contrast mode is enabled.
+     *
+     * In high contrast mode, background images can not be set and
+     * they are always returned as 'none'.
+     *
+     * @return {Boolean} True if in high contrast mode
+     */
+    function highContrast() {
+        var c, $div, el, rgb;
+
+        // High contrast mode deals with white and black
+        rgb = 'rgb(120,2,153)';
+        $div = $('<div style="width:0;height:0;color:' + rgb + '">');
+        $('body').append($div);
+        el = $div.get(0);
+
+        // $div.css() will get the style definition, not
+        // the actually displaying style
+        if (wind.getComputedStyle) {
+            c = wind.getComputedStyle(el, '').color;
+        } else {
+            c = (el.currentStyle || el.style || {}).color;
         }
-        filenameTag.text(filename);
-      };
 
-      // Account for input saved across refreshes
-      setFilename();
+        $div.remove();
+        return c.replace(/ /g, '') !== rgb;
+    }
 
-      $el
-      .css("opacity", 0)
-      .bind({
-        "focus.uniform": function(){
-          divTag.addClass(options.focusClass);
-        },
-        "blur.uniform": function(){
-          divTag.removeClass(options.focusClass);
-        },
-        "mousedown.uniform": function() {
-          if(!$(elem).is(":disabled")){
-            divTag.addClass(options.activeClass);
-          }
-        },
-        "mouseup.uniform": function() {
-          divTag.removeClass(options.activeClass);
-        },
-        "mouseenter.uniform": function() {
-          divTag.addClass(options.hoverClass);
-        },
-        "mouseleave.uniform": function() {
-          divTag.removeClass(options.hoverClass);
-          divTag.removeClass(options.activeClass);
+    /**
+     * Change text into safe HTML
+     *
+     * @param {String} text
+     * @return {String} HTML version
+     */
+    function htmlify(text) {
+        if (!text) {
+            return "";
+        }
+
+        return $('<span />').text(text).html();
+    }
+
+    /**
+     * If not MSIE, return false.
+     * If it is, return the version number.
+     *
+     * @return {Boolean}|{Number}
+     */
+    function isMsie() {
+        return navigator.cpuClass && !navigator.product;
+    }
+
+    /**
+     * Return true if this version of IE allows styling
+     *
+     * @return {Boolean}
+     */
+    function isMsieSevenOrNewer() {
+        return wind.XMLHttpRequest !== undefined;
+    }
+
+    /**
+     * Test if the element is a multiselect
+     *
+     * @param {jQuery} $el Element
+     * @return {Boolean} true/false
+     */
+    function isMultiselect($el) {
+        var elSize;
+
+        if ($el[0].multiple) {
+            return true;
         }
-      });
-
-      // IE7 doesn't fire onChange until blur or second fire.
-      if ($.browser.msie){
-        // IE considers browser chrome blocking I/O, so it
-        // suspends tiemouts until after the file has been selected.
-        $el.bind('click.uniform.ie7', function() {
-          setTimeout(setFilename, 0);
+
+        elSize = attrOrProp($el, "size");
+
+        return !(!elSize || elSize <= 1);
+    }
+
+    /**
+     * Meaningless utility function.  Used mostly for improving minification.
+     *
+     * @return {Boolean}
+     */
+    function returnFalse() {
+        return false;
+    }
+
+    /**
+     * noSelect plugin, very slightly modified
+     * http://mths.be/noselect v1.0.3
+     *
+     * @param {jQuery} $elem Element that we don't want to select
+     * @param {Object} options Uniform options for the element
+     */
+    function noSelect($elem, options) {
+        var none = 'none';
+        bindMany($elem, options, {
+            'selectstart dragstart mousedown': returnFalse
         });
-      }else{
-        // All other browsers behave properly
-        $el.bind('change.uniform', setFilename);
-      }
-
-      //handle defaults
-      if($el.attr("disabled")){
-        //box is checked by default, check our box
-        divTag.addClass(options.disabledClass);
-      }
-      
-      $.uniform.noSelect(filenameTag);
-      $.uniform.noSelect(btnTag);
-      
-      storeElement(elem);
 
+        $elem.css({
+            MozUserSelect: none,
+            msUserSelect: none,
+            webkitUserSelect: none,
+            userSelect: none
+        });
     }
-    
-    $.uniform.restore = function(elem){
-      if(elem == undefined){
-        elem = $($.uniform.elements);
-      }
-      
-      $(elem).each(function(){
-        if($(this).is(":checkbox")){
-          //unwrap from span and div
-          $(this).unwrap().unwrap();
-        }else if($(this).is("select")){
-          //remove sibling span
-          $(this).siblings("span").remove();
-          //unwrap parent div
-          $(this).unwrap();
-        }else if($(this).is(":radio")){
-          //unwrap from span and div
-          $(this).unwrap().unwrap();
-        }else if($(this).is(":file")){
-          //remove sibling spans
-          $(this).siblings("span").remove();
-          //unwrap parent div
-          $(this).unwrap();
-        }else if($(this).is("button, :submit, :reset, a, input[type='button']")){
-          //unwrap from span and div
-          $(this).unwrap().unwrap();
+
+    /**
+     * Updates the filename tag based on the value of the real input
+     * element.
+     *
+     * @param {jQuery} $el Actual form element
+     * @param {jQuery} $filenameTag Span/div to update
+     * @param {Object} options Uniform options for this element
+     */
+    function setFilename($el, $filenameTag, options) {
+        var filename = $el.val();
+
+        if (filename === "") {
+            filename = options.fileDefaultHtml;
+        } else {
+            filename = filename.split(/[\/\\]+/);
+            filename = filename[(filename.length - 1)];
         }
-        
-        //unbind events
-        $(this).unbind(".uniform");
-        
-        //reset inline style
-        $(this).css("opacity", "1");
-        
-        //remove item from list of uniformed elements
-        var index = $.inArray($(elem), $.uniform.elements);
-        $.uniform.elements.splice(index, 1);
-      });
-    };
 
-    function storeElement(elem){
-      //store this element in our global array
-      elem = $(elem).get();
-      if(elem.length > 1){
-        $.each(elem, function(i, val){
-          $.uniform.elements.push(val);
+        $filenameTag.text(filename);
+    }
+
+    /**
+     * Function from jQuery to swap some CSS values, run a callback,
+     * then restore the CSS.  Modified to pass JSLint and handle undefined
+     * values with 'use strict'.
+     *
+     * @param {jQuery} $elements Element
+     * @param {Object} newCss CSS values to swap out
+     * @param {Function} callback Function to run
+     */
+    function swap($elements, newCss, callback) {
+        var restore, item;
+
+        restore = [];
+
+        $elements.each(function () {
+            var name;
+
+            for (name in newCss) {
+                if (Object.prototype.hasOwnProperty.call(newCss, name)) {
+                    restore.push({
+                        el: this,
+                        name: name,
+                        old: this.style[name]
+                    });
+
+                    this.style[name] = newCss[name];
+                }
+            }
         });
-      }else{
-        $.uniform.elements.push(elem);
-      }
+
+        callback();
+
+        while (restore.length) {
+            item = restore.pop();
+            item.el.style[item.name] = item.old;
+        }
+    }
+
+    /**
+     * The browser doesn't provide sizes of elements that are not visible.
+     * This will clone an element and add it to the DOM for calculations.
+     *
+     * @param {jQuery} $el
+     * @param {Function} callback
+     */
+    function sizingInvisible($el, callback) {
+        var targets;
+
+        // We wish to target ourselves and any parents as long as
+        // they are not visible
+        targets = $el.parents();
+        targets.push($el[0]);
+        targets = targets.not(':visible');
+        swap(targets, {
+            visibility: "hidden",
+            display: "block",
+            position: "absolute"
+        }, callback);
+    }
+
+    /**
+     * Standard way to unwrap the div/span combination from an element
+     *
+     * @param {jQuery} $el Element that we wish to preserve
+     * @param {Object} options Uniform options for the element
+     * @return {Function} This generated function will perform the given work
+     */
+    function unwrapUnwrapUnbindFunction($el, options) {
+        return function () {
+            $el.unwrap().unwrap().unbind(options.eventNamespace);
+        };
     }
-    
-    //noSelect v1.0
-    $.uniform.noSelect = function(elem) {
-      function f() {
-       return false;
-      };
-      $(elem).each(function() {
-       this.onselectstart = this.ondragstart = f; // Webkit & IE
-       $(this)
-        .mousedown(f) // Webkit & Opera
-        .css({ MozUserSelect: 'none' }); // Firefox
-      });
-     };
-
-    $.uniform.update = function(elem){
-      if(elem == undefined){
-        elem = $($.uniform.elements);
-      }
-      //sanitize input
-      elem = $(elem);
-
-      elem.each(function(){
-        //do to each item in the selector
-        //function to reset all classes
-        var $e = $(this);
-
-        if($e.is("select")){
-          //element is a select
-          var spanTag = $e.siblings("span");
-          var divTag = $e.parent("div");
-
-          divTag.removeClass(options.hoverClass+" "+options.focusClass+" "+options.activeClass);
-
-          //reset current selected text
-          spanTag.html($e.find(":selected").html());
-
-          if($e.is(":disabled")){
-            divTag.addClass(options.disabledClass);
-          }else{
-            divTag.removeClass(options.disabledClass);
-          }
-
-        }else if($e.is(":checkbox")){
-          //element is a checkbox
-          var spanTag = $e.closest("span");
-          var divTag = $e.closest("div");
-
-          divTag.removeClass(options.hoverClass+" "+options.focusClass+" "+options.activeClass);
-          spanTag.removeClass(options.checkedClass);
-
-          if($e.is(":checked")){
-            spanTag.addClass(options.checkedClass);
-          }
-          if($e.is(":disabled")){
-            divTag.addClass(options.disabledClass);
-          }else{
-            divTag.removeClass(options.disabledClass);
-          }
-
-        }else if($e.is(":radio")){
-          //element is a radio
-          var spanTag = $e.closest("span");
-          var divTag = $e.closest("div");
-
-          divTag.removeClass(options.hoverClass+" "+options.focusClass+" "+options.activeClass);
-          spanTag.removeClass(options.checkedClass);
-
-          if($e.is(":checked")){
-            spanTag.addClass(options.checkedClass);
-          }
-
-          if($e.is(":disabled")){
-            divTag.addClass(options.disabledClass);
-          }else{
-            divTag.removeClass(options.disabledClass);
-          }
-        }else if($e.is(":file")){
-          var divTag = $e.parent("div");
-          var filenameTag = $e.siblings(options.filenameClass);
-          btnTag = $e.siblings(options.fileBtnClass);
-
-          divTag.removeClass(options.hoverClass+" "+options.focusClass+" "+options.activeClass);
-
-          filenameTag.text($e.val());
-
-          if($e.is(":disabled")){
-            divTag.addClass(options.disabledClass);
-          }else{
-            divTag.removeClass(options.disabledClass);
-          }
-        }else if($e.is(":submit") || $e.is(":reset") || $e.is("button") || $e.is("a") || elem.is("input[type=button]")){
-          var divTag = $e.closest("div");
-          divTag.removeClass(options.hoverClass+" "+options.focusClass+" "+options.activeClass);
-          
-          if($e.is(":disabled")){
-            divTag.addClass(options.disabledClass);
-          }else{
-            divTag.removeClass(options.disabledClass);
-          }
-          
+
+    var allowStyling = true,  // False if IE6 or other unsupported browsers
+        highContrastTest = false,  // Was the high contrast test ran?
+        uniformHandlers = [  // Objects that take care of "unification"
+            {
+                // Buttons
+                match: function ($el) {
+                    return $el.is("a, button, :submit, :reset, input[type='button']");
+                },
+                apply: function ($el, options) {
+                    var $div, defaultSpanHtml, ds, getHtml, doingClickEvent;
+                    defaultSpanHtml = options.submitDefaultHtml;
+
+                    if ($el.is(":reset")) {
+                        defaultSpanHtml = options.resetDefaultHtml;
+                    }
+
+                    if ($el.is("a, button")) {
+                        // Use the HTML inside the tag
+                        getHtml = function () {
+                            return $el.html() || defaultSpanHtml;
+                        };
+                    } else {
+                        // Use the value property of the element
+                        getHtml = function () {
+                            return htmlify(attrOrProp($el, "value")) || defaultSpanHtml;
+                        };
+                    }
+
+                    ds = divSpan($el, options, {
+                        divClass: options.buttonClass,
+                        spanHtml: getHtml()
+                    });
+                    $div = ds.div;
+                    bindUi($el, $div, options);
+                    doingClickEvent = false;
+                    bindMany($div, options, {
+                        "click touchend": function () {
+                            var ev, res, target, href;
+
+                            if (doingClickEvent) {
+                                return;
+                            }
+
+                            if ($el.is(':disabled')) {
+                                return;
+                            }
+
+                            doingClickEvent = true;
+
+                            if ($el[0].dispatchEvent) {
+                                ev = document.createEvent("MouseEvents");
+                                ev.initEvent("click", true, true);
+                                res = $el[0].dispatchEvent(ev);
+
+                                if ($el.is('a') && res) {
+                                    target = attrOrProp($el, 'target');
+                                    href = attrOrProp($el, 'href');
+
+                                    if (!target || target === '_self') {
+                                        document.location.href = href;
+                                    } else {
+                                        wind.open(href, target);
+                                    }
+                                }
+                            } else {
+                                $el.click();
+                            }
+
+                            doingClickEvent = false;
+                        }
+                    });
+                    noSelect($div, options);
+                    return {
+                        remove: function () {
+                            // Move $el out
+                            $div.after($el);
+
+                            // Remove div and span
+                            $div.remove();
+
+                            // Unbind events
+                            $el.unbind(options.eventNamespace);
+                            return $el;
+                        },
+                        update: function () {
+                            classClearStandard($div, options);
+                            classUpdateDisabled($div, $el, options);
+                            $el.detach();
+                            ds.span.html(getHtml()).append($el);
+                        }
+                    };
+                }
+            },
+            {
+                // Checkboxes
+                match: function ($el) {
+                    return $el.is(":checkbox");
+                },
+                apply: function ($el, options) {
+                    var ds, $div, $span;
+                    ds = divSpan($el, options, {
+                        divClass: options.checkboxClass
+                    });
+                    $div = ds.div;
+                    $span = ds.span;
+
+                    // Add focus classes, toggling, active, etc.
+                    bindUi($el, $div, options);
+                    bindMany($el, options, {
+                        "click touchend": function () {
+                            classUpdateChecked($span, $el, options);
+                        }
+                    });
+                    classUpdateChecked($span, $el, options);
+                    return {
+                        remove: unwrapUnwrapUnbindFunction($el, options),
+                        update: function () {
+                            classClearStandard($div, options);
+                            $span.removeClass(options.checkedClass);
+                            classUpdateChecked($span, $el, options);
+                            classUpdateDisabled($div, $el, options);
+                        }
+                    };
+                }
+            },
+            {
+                // File selection / uploads
+                match: function ($el) {
+                    return $el.is(":file");
+                },
+                apply: function ($el, options) {
+                    var ds, $div, $filename, $button;
+
+                    // The "span" is the button
+                    ds = divSpan($el, options, {
+                        divClass: options.fileClass,
+                        spanClass: options.fileButtonClass,
+                        spanHtml: options.fileButtonHtml,
+                        spanWrap: "after"
+                    });
+                    $div = ds.div;
+                    $button = ds.span;
+                    $filename = $("<span />").html(options.fileDefaultHtml);
+                    $filename.addClass(options.filenameClass);
+                    $filename = divSpanWrap($el, $filename, "after");
+
+                    // Set the size
+                    if (!attrOrProp($el, "size")) {
+                        attrOrProp($el, "size", $div.width() / 10);
+                    }
+
+                    // Actions
+                    function filenameUpdate() {
+                        setFilename($el, $filename, options);
+                    }
+
+                    bindUi($el, $div, options);
+
+                    // Account for input saved across refreshes
+                    filenameUpdate();
+
+                    // IE7 doesn't fire onChange until blur or second fire.
+                    if (isMsie()) {
+                        // IE considers browser chrome blocking I/O, so it
+                        // suspends tiemouts until after the file has
+                        // been selected.
+                        bindMany($el, options, {
+                            click: function () {
+                                $el.trigger("change");
+                                setTimeout(filenameUpdate, 0);
+                            }
+                        });
+                    } else {
+                        // All other browsers behave properly
+                        bindMany($el, options, {
+                            change: filenameUpdate
+                        });
+                    }
+
+                    noSelect($filename, options);
+                    noSelect($button, options);
+                    return {
+                        remove: function () {
+                            // Remove filename and button
+                            $filename.remove();
+                            $button.remove();
+
+                            // Unwrap parent div, remove events
+                            return $el.unwrap().unbind(options.eventNamespace);
+                        },
+                        update: function () {
+                            classClearStandard($div, options);
+                            setFilename($el, $filename, options);
+                            classUpdateDisabled($div, $el, options);
+                        }
+                    };
+                }
+            },
+            {
+                // Input fields (text)
+                match: function ($el) {
+                    if ($el.is("input")) {
+                        var t = (" " + attrOrProp($el, "type") + " ").toLowerCase(),
+                            allowed = " color date datetime datetime-local email month number password search tel text time url week ";
+                        return allowed.indexOf(t) >= 0;
+                    }
+
+                    return false;
+                },
+                apply: function ($el, options) {
+                    var elType, $wrapper;
+
+                    elType = attrOrProp($el, "type");
+                    $el.addClass(options.inputClass);
+                    $wrapper = wrapWithWrapperClass($el, options);
+                    bindUi($el, $el, options);
+
+                    if (options.inputAddTypeAsClass) {
+                        $el.addClass(elType);
+                    }
+
+                    return {
+                        remove: function () {
+                            $el.removeClass(options.inputClass);
+
+                            if (options.inputAddTypeAsClass) {
+                                $el.removeClass(elType);
+                            }
+
+                            if ($wrapper) {
+                                $el.unwrap();
+                            }
+                        },
+                        update: returnFalse
+                    };
+                }
+            },
+            {
+                // Radio buttons
+                match: function ($el) {
+                    return $el.is(":radio");
+                },
+                apply: function ($el, options) {
+                    var ds, $div, $span;
+                    ds = divSpan($el, options, {
+                        divClass: options.radioClass
+                    });
+                    $div = ds.div;
+                    $span = ds.span;
+
+                    // Add classes for focus, handle active, checked
+                    bindUi($el, $div, options);
+                    bindMany($el, options, {
+                        "click touchend": function () {
+                            // Find all radios with the same name, then update
+                            // them with $.uniform.update() so the right
+                            // per-element options are used
+                            $.uniform.update($(':radio[name="' + attrOrProp($el, "name") + '"]'));
+                        }
+                    });
+                    classUpdateChecked($span, $el, options);
+                    return {
+                        remove: unwrapUnwrapUnbindFunction($el, options),
+                        update: function () {
+                            classClearStandard($div, options);
+                            classUpdateChecked($span, $el, options);
+                            classUpdateDisabled($div, $el, options);
+                        }
+                    };
+                }
+            },
+            {
+                // Select lists, but do not style multiselects here
+                match: function ($el) {
+                    return !!($el.is("select") && !isMultiselect($el));
+                },
+                apply: function ($el, options) {
+                    var ds, $div, $span, origElemWidth;
+
+                    if (options.selectAutoWidth) {
+                        sizingInvisible($el, function () {
+                            origElemWidth = $el.width();
+                        });
+                    }
+
+                    ds = divSpan($el, options, {
+                        divClass: options.selectClass,
+                        spanHtml: ($el.find(":selected:first") || $el.find("option:first")).html(),
+                        spanWrap: "before"
+                    });
+                    $div = ds.div;
+                    $span = ds.span;
+
+                    if (options.selectAutoWidth) {
+                        // Use the width of the select and adjust the
+                        // span and div accordingly
+                        sizingInvisible($el, function () {
+                            // Force "display: block" - related to bug #287
+                            swap($([$span[0], $div[0]]), {
+                                display: "block"
+                            }, function () {
+                                var spanPad;
+                                spanPad = $span.outerWidth() - $span.width();
+                                $div.width(origElemWidth + spanPad);
+                                $span.width(origElemWidth);
+                            });
+                        });
+                    } else {
+                        // Force the select to fill the size of the div
+                        $div.addClass('fixedWidth');
+                    }
+
+                    // Take care of events
+                    bindUi($el, $div, options);
+                    bindMany($el, options, {
+                        change: function () {
+                            $span.html($el.find(":selected").html());
+                            $div.removeClass(options.activeClass);
+                        },
+                        "click touchend": function () {
+                            // IE7 and IE8 may not update the value right
+                            // until after click event - issue #238
+                            var selHtml = $el.find(":selected").html();
+
+                            if ($span.html() !== selHtml) {
+                                // Change was detected
+                                // Fire the change event on the select tag
+                                $el.trigger('change');
+                            }
+                        },
+                        keyup: function () {
+                            $span.html($el.find(":selected").html());
+                        }
+                    });
+                    noSelect($span, options);
+                    return {
+                        remove: function () {
+                            // Remove sibling span
+                            $span.remove();
+
+                            // Unwrap parent div
+                            $el.unwrap().unbind(options.eventNamespace);
+                            return $el;
+                        },
+                        update: function () {
+                            if (options.selectAutoWidth) {
+                                // Easier to remove and reapply formatting
+                                $.uniform.restore($el);
+                                $el.uniform(options);
+                            } else {
+                                classClearStandard($div, options);
+
+                                // Reset current selected text
+                                $el[0].selectedIndex = $el[0].selectedIndex; // Force IE to have a ":selected" option (if the field was reset for example)
+                                $span.html($el.find(":selected").html());
+                                classUpdateDisabled($div, $el, options);
+                            }
+                        }
+                    };
+                }
+            },
+            {
+                // Select lists - multiselect lists only
+                match: function ($el) {
+                    return !!($el.is("select") && isMultiselect($el));
+                },
+                apply: function ($el, options) {
+                    var $wrapper;
+
+                    $el.addClass(options.selectMultiClass);
+                    $wrapper = wrapWithWrapperClass($el, options);
+                    bindUi($el, $el, options);
+
+                    return {
+                        remove: function () {
+                            $el.removeClass(options.selectMultiClass);
+
+                            if ($wrapper) {
+                                $el.unwrap();
+                            }
+                        },
+                        update: returnFalse
+                    };
+                }
+            },
+            {
+                // Textareas
+                match: function ($el) {
+                    return $el.is("textarea");
+                },
+                apply: function ($el, options) {
+                    var $wrapper;
+
+                    $el.addClass(options.textareaClass);
+                    $wrapper = wrapWithWrapperClass($el, options);
+                    bindUi($el, $el, options);
+
+                    return {
+                        remove: function () {
+                            $el.removeClass(options.textareaClass);
+
+                            if ($wrapper) {
+                                $el.unwrap();
+                            }
+                        },
+                        update: returnFalse
+                    };
+                }
+            }
+        ];
+
+    // IE6 can't be styled - can't set opacity on select
+    if (isMsie() && !isMsieSevenOrNewer()) {
+        allowStyling = false;
+    }
+
+    $.uniform = {
+        // Default options that can be overridden globally or when uniformed
+        // globally:  $.uniform.defaults.fileButtonHtml = "Pick A File";
+        // on uniform:  $('input').uniform({fileButtonHtml: "Pick a File"});
+        defaults: {
+            activeClass: "active",
+            autoHide: true,
+            buttonClass: "button",
+            checkboxClass: "checker",
+            checkedClass: "checked",
+            disabledClass: "disabled",
+            eventNamespace: ".uniform",
+            fileButtonClass: "action",
+            fileButtonHtml: "Choose File",
+            fileClass: "uploader",
+            fileDefaultHtml: "No file selected",
+            filenameClass: "filename",
+            focusClass: "focus",
+            hoverClass: "hover",
+            idPrefix: "uniform",
+            inputAddTypeAsClass: true,
+            inputClass: "uniform-input",
+            radioClass: "radio",
+            resetDefaultHtml: "Reset",
+            resetSelector: false,  // We'll use our own function when you don't specify one
+            selectAutoWidth: true,
+            selectClass: "selector",
+            selectMultiClass: "uniform-multiselect",
+            submitDefaultHtml: "Submit",  // Only text allowed
+            textareaClass: "uniform",
+            useID: true,
+            wrapperClass: null
+        },
+
+        // All uniformed elements - DOM objects
+        elements: []
+    };
+
+    $.fn.uniform = function (options) {
+        var el = this;
+        options = $.extend({}, $.uniform.defaults, options);
+
+        // If we are in high contrast mode, do not allow styling
+        if (!highContrastTest) {
+            highContrastTest = true;
+
+            if (highContrast()) {
+                allowStyling = false;
+            }
         }
-        
-      });
+
+        // Only uniform on browsers that work
+        if (!allowStyling) {
+            return this;
+        }
+
+        // Code for specifying a reset button
+        if (options.resetSelector) {
+            $(options.resetSelector).mouseup(function () {
+                wind.setTimeout(function () {
+                    $.uniform.update(el);
+                }, 10);
+            });
+        }
+
+        return this.each(function () {
+            var $el = $(this), i, handler, callbacks;
+
+            // Avoid uniforming elements already uniformed - just update
+            if ($el.data("uniformed")) {
+                $.uniform.update($el);
+                return;
+            }
+
+            // See if we have any handler for this type of element
+            for (i = 0; i < uniformHandlers.length; i = i + 1) {
+                handler = uniformHandlers[i];
+
+                if (handler.match($el, options)) {
+                    callbacks = handler.apply($el, options);
+                    $el.data("uniformed", callbacks);
+
+                    // Store element in our global array
+                    $.uniform.elements.push($el.get(0));
+                    return;
+                }
+            }
+
+            // Could not style this element
+        });
     };
 
-    return this.each(function() {
-      if($.support.selectOpacity){
-        var elem = $(this);
+    $.uniform.restore = $.fn.uniform.restore = function (elem) {
+        if (elem === undef) {
+            elem = $.uniform.elements;
+        }
+
+        $(elem).each(function () {
+            var $el = $(this), index, elementData;
+            elementData = $el.data("uniformed");
+
+            // Skip elements that are not uniformed
+            if (!elementData) {
+                return;
+            }
 
-        if(elem.is("select")){
-          //element is a select
-          if(elem.attr("multiple") != true){
-            //element is not a multi-select
-            if(elem.attr("size") == undefined || elem.attr("size") <= 1){
-              doSelect(elem);
+            // Unbind events, remove additional markup that was added
+            elementData.remove();
+
+            // Remove item from list of uniformed elements
+            index = $.inArray(this, $.uniform.elements);
+
+            if (index >= 0) {
+                $.uniform.elements.splice(index, 1);
             }
-          }
-        }else if(elem.is(":checkbox")){
-          //element is a checkbox
-          doCheckbox(elem);
-        }else if(elem.is(":radio")){
-          //element is a radio
-          doRadio(elem);
-        }else if(elem.is(":file")){
-          //element is a file upload
-          doFile(elem);
-        }else if(elem.is(":text, :password, input[type='email']")){
-          doInput(elem);
-        }else if(elem.is("textarea")){
-          doTextarea(elem);
-        }else if(elem.is("a") || elem.is(":submit") || elem.is(":reset") || elem.is("button") || elem.is("input[type=button]")){
-          doButton(elem);
+
+            $el.removeData("uniformed");
+        });
+    };
+
+    $.uniform.update = $.fn.uniform.update = function (elem) {
+        if (elem === undef) {
+            elem = $.uniform.elements;
         }
-          
-      }
-    });
-  };
-})(jQuery);
+
+        $(elem).each(function () {
+            var $el = $(this), elementData;
+            elementData = $el.data("uniformed");
+
+            // Skip elements that are not uniformed
+            if (!elementData) {
+                return;
+            }
+
+            elementData.update($el, elementData.options);
+        });
+    };
+}(this, jQuery));