Actualización

web/assets/multiselect-two-sides/lib/google-code-prettify/prettify.css

@@ -0,0 +1,30 @@
+.com { color: #93a1a1; }
+.lit { color: #195f91; }
+.pun, .opn, .clo { color: #93a1a1; }
+.fun { color: #dc322f; }
+.str, .atv { color: #D14; }
+.kwd, .linenums .tag { color: #1e347b; }
+.typ, .atn, .dec, .var { color: teal; }
+.pln { color: #48484c; }
+
+.prettyprint {
+  padding: 8px;
+  background-color: #f7f7f9;
+  border: 1px solid #e1e1e8;
+}
+.prettyprint.linenums {
+  -webkit-box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
+     -moz-box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
+          box-shadow: inset 40px 0 0 #fbfbfc, inset 41px 0 0 #ececf0;
+}
+
+/* Specify class=linenums on a pre to get line numbering */
+ol.linenums {
+  margin: 0 0 0 33px; /* IE indents via margin-left */
+} 
+ol.linenums li {
+  padding-left: 12px;
+  color: #bebec5;
+  line-height: 18px;
+  text-shadow: 0 1px 0 #fff;
+}

web/assets/multiselect-two-sides/lib/jasmine-html.js

@@ -0,0 +1,188 @@
+jasmine.TrivialReporter = function(doc) {
+  this.document = doc || document;
+  this.suiteDivs = {};
+  this.logRunningSpecs = false;
+};
+
+jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) { el.appendChild(child); }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
+  var showPassed, showSkipped;
+
+  this.outerDiv = this.createDom('div', { className: 'jasmine_reporter' },
+      this.createDom('div', { className: 'banner' },
+        this.createDom('div', { className: 'logo' },
+            this.createDom('a', { href: 'http://pivotal.github.com/jasmine/', target: "_blank" }, "Jasmine"),
+            this.createDom('span', { className: 'version' }, runner.env.versionString())),
+        this.createDom('div', { className: 'options' },
+            "Show ",
+            showPassed = this.createDom('input', { id: "__jasmine_TrivialReporter_showPassed__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showPassed__" }, " passed "),
+            showSkipped = this.createDom('input', { id: "__jasmine_TrivialReporter_showSkipped__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showSkipped__" }, " skipped")
+            )
+          ),
+
+      this.runnerDiv = this.createDom('div', { className: 'runner running' },
+          this.createDom('a', { className: 'run_spec', href: '?' }, "run all"),
+          this.runnerMessageSpan = this.createDom('span', {}, "Running..."),
+          this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, ""))
+      );
+
+  this.document.body.appendChild(this.outerDiv);
+
+  var suites = runner.suites();
+  for (var i = 0; i < suites.length; i++) {
+    var suite = suites[i];
+    var suiteDiv = this.createDom('div', { className: 'suite' },
+        this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"),
+        this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description));
+    this.suiteDivs[suite.id] = suiteDiv;
+    var parentDiv = this.outerDiv;
+    if (suite.parentSuite) {
+      parentDiv = this.suiteDivs[suite.parentSuite.id];
+    }
+    parentDiv.appendChild(suiteDiv);
+  }
+
+  this.startedAt = new Date();
+
+  var self = this;
+  showPassed.onclick = function(evt) {
+    if (showPassed.checked) {
+      self.outerDiv.className += ' show-passed';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, '');
+    }
+  };
+
+  showSkipped.onclick = function(evt) {
+    if (showSkipped.checked) {
+      self.outerDiv.className += ' show-skipped';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, '');
+    }
+  };
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) {
+  var results = runner.results();
+  var className = (results.failedCount > 0) ? "runner failed" : "runner passed";
+  this.runnerDiv.setAttribute("class", className);
+  //do it twice for IE
+  this.runnerDiv.setAttribute("className", className);
+  var specs = runner.specs();
+  var specCount = 0;
+  for (var i = 0; i < specs.length; i++) {
+    if (this.specFilter(specs[i])) {
+      specCount++;
+    }
+  }
+  var message = "" + specCount + " spec" + (specCount == 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s");
+  message += " in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s";
+  this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild);
+
+  this.finishedAtSpan.appendChild(document.createTextNode("Finished at " + new Date().toString()));
+};
+
+jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) {
+  var results = suite.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.totalCount == 0) { // todo: change this to check results.skipped
+    status = 'skipped';
+  }
+  this.suiteDivs[suite.id].className += " " + status;
+};
+
+jasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) {
+  if (this.logRunningSpecs) {
+    this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+  }
+};
+
+jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
+  var results = spec.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+  var specDiv = this.createDom('div', { className: 'spec '  + status },
+      this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"),
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(spec.getFullName()),
+        title: spec.getFullName()
+      }, spec.description));
+
+
+  var resultItems = results.getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    specDiv.appendChild(messagesDiv);
+  }
+
+  this.suiteDivs[spec.suite.id].appendChild(specDiv);
+};
+
+jasmine.TrivialReporter.prototype.log = function() {
+  var console = jasmine.getGlobal().console;
+  if (console && console.log) {
+    if (console.log.apply) {
+      console.log.apply(console, arguments);
+    } else {
+      console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+    }
+  }
+};
+
+jasmine.TrivialReporter.prototype.getLocation = function() {
+  return this.document.location;
+};
+
+jasmine.TrivialReporter.prototype.specFilter = function(spec) {
+  var paramMap = {};
+  var params = this.getLocation().search.substring(1).split('&');
+  for (var i = 0; i < params.length; i++) {
+    var p = params[i].split('=');
+    paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+  }
+
+  if (!paramMap["spec"]) return true;
+  return spec.getFullName().indexOf(paramMap["spec"]) == 0;
+};

web/assets/multiselect-two-sides/lib/jasmine-jquery-1.1.2.js

@@ -0,0 +1,203 @@
+var readFixtures = function() {
+  return jasmine.getFixtures().proxyCallTo_('read', arguments);
+};
+
+var loadFixtures = function() {
+  jasmine.getFixtures().proxyCallTo_('load', arguments);
+};
+
+var setFixtures = function(html) {
+  jasmine.getFixtures().set(html);
+}
+
+var sandbox = function(attributes) {
+  return jasmine.getFixtures().sandbox(attributes);
+};
+
+jasmine.getFixtures = function() {
+  return jasmine.currentFixtures_ = jasmine.currentFixtures_ || new jasmine.Fixtures();
+};
+
+jasmine.Fixtures = function() {
+  this.containerId = 'jasmine-fixtures';
+  this.fixturesCache_ = {};
+};
+
+jasmine.Fixtures.prototype.set = function(html) {
+  this.cleanUp();
+  this.createContainer_(html);
+};
+
+jasmine.Fixtures.prototype.load = function() {
+  this.cleanUp();
+  this.createContainer_(this.read.apply(this, arguments));
+};
+
+jasmine.Fixtures.prototype.read = function() {
+  var htmlChunks = [];
+
+  var fixtureUrls = arguments;
+  for(var urlCount = fixtureUrls.length, urlIndex = 0; urlIndex < urlCount; urlIndex++) {
+    htmlChunks.push(this.getFixtureHtml_(fixtureUrls[urlIndex]));
+  }
+
+  return htmlChunks.join('');
+};
+
+jasmine.Fixtures.prototype.clearCache = function() {
+  this.fixturesCache_ = {};
+};
+
+jasmine.Fixtures.prototype.cleanUp = function() {
+  $('#' + this.containerId).remove();
+};
+
+jasmine.Fixtures.prototype.sandbox = function(attributes) {
+  var attributesToSet = attributes || {};
+  return $('<div id="sandbox" />').attr(attributesToSet);
+};
+
+jasmine.Fixtures.prototype.createContainer_ = function(html) {
+  var container = $('<div id="' + this.containerId + '" />');
+  container.html(html);
+  $('body').append(container);
+};
+
+jasmine.Fixtures.prototype.getFixtureHtml_ = function(url) {  
+  if (typeof this.fixturesCache_[url] == 'undefined') {
+    this.loadFixtureIntoCache_(url);
+  }
+  return this.fixturesCache_[url];
+};
+
+jasmine.Fixtures.prototype.loadFixtureIntoCache_ = function(url) {
+  var self = this;
+  $.ajax({
+    async: false, // must be synchronous to guarantee that no tests are run before fixture is loaded
+    cache: false,
+    dataType: 'html',
+    url: url,
+    success: function(data) {
+      self.fixturesCache_[url] = data;
+    }
+  });
+};
+
+jasmine.Fixtures.prototype.proxyCallTo_ = function(methodName, passedArguments) {
+  return this[methodName].apply(this, passedArguments);
+};
+
+
+jasmine.JQuery = function() {};
+
+jasmine.JQuery.browserTagCaseIndependentHtml = function(html) {
+  return $('<div/>').append(html).html();
+};
+
+jasmine.JQuery.elementToString = function(element) {
+  return $('<div />').append(element.clone()).html();
+};
+
+jasmine.JQuery.matchersClass = {};
+
+
+(function(){
+  var jQueryMatchers = {
+    toHaveClass: function(className) {
+      return this.actual.hasClass(className);
+    },
+
+    toBeVisible: function() {
+      return this.actual.is(':visible');
+    },
+
+    toBeHidden: function() {
+      return this.actual.is(':hidden');
+    },
+
+    toBeSelected: function() {
+      return this.actual.is(':selected');
+    },
+
+    toBeChecked: function() {
+      return this.actual.is(':checked');
+    },
+
+    toBeEmpty: function() {
+      return this.actual.is(':empty');
+    },
+
+    toExist: function() {
+      return this.actual.size() > 0;
+    },
+
+    toHaveAttr: function(attributeName, expectedAttributeValue) {
+      return hasProperty(this.actual.attr(attributeName), expectedAttributeValue);
+    },
+
+    toHaveId: function(id) {
+      return this.actual.attr('id') == id;
+    },
+
+    toHaveHtml: function(html) {
+      return this.actual.html() == jasmine.JQuery.browserTagCaseIndependentHtml(html);
+    },
+
+    toHaveText: function(text) {
+      return this.actual.text() == text;
+    },
+
+    toHaveValue: function(value) {
+      return this.actual.val() == value;
+    },
+
+    toHaveData: function(key, expectedValue) {
+      return hasProperty(this.actual.data(key), expectedValue);
+    },
+
+    toBe: function(selector) {
+      return this.actual.is(selector);
+    },
+
+    toContain: function(selector) {
+      return this.actual.find(selector).size() > 0;
+    }
+  };
+
+  var hasProperty = function(actualValue, expectedValue) {
+    if (expectedValue === undefined) {
+      return actualValue !== undefined;
+    }
+    return actualValue == expectedValue;
+  };
+
+  var bindMatcher = function(methodName) {
+    var builtInMatcher = jasmine.Matchers.prototype[methodName];
+
+    jasmine.JQuery.matchersClass[methodName] = function() {
+      if (this.actual instanceof jQuery) {
+        var result = jQueryMatchers[methodName].apply(this, arguments);
+        this.actual = jasmine.JQuery.elementToString(this.actual);
+        return result;
+      }
+
+      if (builtInMatcher) {
+        return builtInMatcher.apply(this, arguments);
+      }
+
+      return false;
+    };
+  };
+
+  for(var methodName in jQueryMatchers) {
+    bindMatcher(methodName);
+  }
+})();
+
+beforeEach(function() {
+  this.addMatchers(jasmine.JQuery.matchersClass);
+});
+
+afterEach(function() {
+  jasmine.getFixtures().cleanUp();
+});

web/assets/multiselect-two-sides/lib/jasmine.css

@@ -0,0 +1,166 @@
+body {
+  font-family: "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif;
+}
+
+
+.jasmine_reporter a:visited, .jasmine_reporter a {
+  color: #303; 
+}
+
+.jasmine_reporter a:hover, .jasmine_reporter a:active {
+  color: blue; 
+}
+
+.run_spec {
+  float:right;
+  padding-right: 5px;
+  font-size: .8em;
+  text-decoration: none;
+}
+
+.jasmine_reporter {
+  margin: 0 5px;
+}
+
+.banner {
+  color: #303;
+  background-color: #fef;
+  padding: 5px;
+}
+
+.logo {
+  float: left;
+  font-size: 1.1em;
+  padding-left: 5px;
+}
+
+.logo .version {
+  font-size: .6em;
+  padding-left: 1em;
+}
+
+.runner.running {
+  background-color: yellow;
+}
+
+
+.options {
+  text-align: right;
+  font-size: .8em;
+}
+
+
+
+
+.suite {
+  border: 1px outset gray;
+  margin: 5px 0;
+  padding-left: 1em;
+}
+
+.suite .suite {
+  margin: 5px; 
+}
+
+.suite.passed {
+  background-color: #dfd;
+}
+
+.suite.failed {
+  background-color: #fdd;
+}
+
+.spec {
+  margin: 5px;
+  padding-left: 1em;
+  clear: both;
+}
+
+.spec.failed, .spec.passed, .spec.skipped {
+  padding-bottom: 5px;
+  border: 1px solid gray;
+}
+
+.spec.failed {
+  background-color: #fbb;
+  border-color: red;
+}
+
+.spec.passed {
+  background-color: #bfb;
+  border-color: green;
+}
+
+.spec.skipped {
+  background-color: #bbb;
+}
+
+.messages {
+  border-left: 1px dashed gray;
+  padding-left: 1em;
+  padding-right: 1em;
+}
+
+.passed {
+  background-color: #cfc;
+  display: none;
+}
+
+.failed {
+  background-color: #fbb;
+}
+
+.skipped {
+  color: #777;
+  background-color: #eee;
+  display: none;
+}
+
+
+/*.resultMessage {*/
+  /*white-space: pre;*/
+/*}*/
+
+.resultMessage span.result {
+  display: block;
+  line-height: 2em;
+  color: black;
+}
+
+.resultMessage .mismatch {
+  color: black;
+}
+
+.stackTrace {
+  white-space: pre;
+  font-size: .8em;
+  margin-left: 10px;
+  max-height: 5em;
+  overflow: auto;
+  border: 1px inset red;
+  padding: 1em;
+  background: #eef;
+}
+
+.finished-at {
+  padding-left: 1em;
+  font-size: .6em;
+}
+
+.show-passed .passed,
+.show-skipped .skipped {
+  display: block;
+}
+
+
+#jasmine_content {
+  position:fixed;
+  right: 100%;
+}
+
+.runner {
+  border: 1px solid gray;
+  display: block;
+  margin: 5px 0;
+  padding: 2px 0 2px 10px;
+}

web/assets/multiselect-two-sides/lib/jquery.simulate.js

@@ -0,0 +1,331 @@
+ /*!
+ * jQuery Simulate v@VERSION - simulate browser mouse and keyboard events
+ * https://github.com/jquery/jquery-simulate
+ *
+ * Copyright jQuery Foundation and other contributors
+ * Released under the MIT license.
+ * http://jquery.org/license
+ *
+ * Date: @DATE
+ */
+
+;(function( $, undefined ) {
+
+var rkeyEvent = /^key/,
+    rmouseEvent = /^(?:mouse|contextmenu)|click/;
+
+$.fn.simulate = function( type, options ) {
+    return this.each(function() {
+        new $.simulate( this, type, options );
+    });
+};
+
+$.simulate = function( elem, type, options ) {
+    var method = $.camelCase( "simulate-" + type );
+
+    this.target = elem;
+    this.options = options;
+
+    if ( this[ method ] ) {
+        this[ method ]();
+    } else {
+        this.simulateEvent( elem, type, options );
+    }
+};
+
+$.extend( $.simulate, {
+
+    keyCode: {
+        BACKSPACE: 8,
+        COMMA: 188,
+        DELETE: 46,
+        DOWN: 40,
+        END: 35,
+        ENTER: 13,
+        ESCAPE: 27,
+        HOME: 36,
+        LEFT: 37,
+        NUMPAD_ADD: 107,
+        NUMPAD_DECIMAL: 110,
+        NUMPAD_DIVIDE: 111,
+        NUMPAD_ENTER: 108,
+        NUMPAD_MULTIPLY: 106,
+        NUMPAD_SUBTRACT: 109,
+        PAGE_DOWN: 34,
+        PAGE_UP: 33,
+        PERIOD: 190,
+        RIGHT: 39,
+        SPACE: 32,
+        TAB: 9,
+        UP: 38
+    },
+
+    buttonCode: {
+        LEFT: 0,
+        MIDDLE: 1,
+        RIGHT: 2
+    }
+});
+
+$.extend( $.simulate.prototype, {
+
+    simulateEvent: function( elem, type, options ) {
+        var event = this.createEvent( type, options );
+        this.dispatchEvent( elem, type, event, options );
+    },
+
+    createEvent: function( type, options ) {
+        if ( rkeyEvent.test( type ) ) {
+            return this.keyEvent( type, options );
+        }
+
+        if ( rmouseEvent.test( type ) ) {
+            return this.mouseEvent( type, options );
+        }
+    },
+
+    mouseEvent: function( type, options ) {
+        var event, eventDoc, doc, body;
+        options = $.extend({
+            bubbles: true,
+            cancelable: (type !== "mousemove"),
+            view: window,
+            detail: 0,
+            screenX: 0,
+            screenY: 0,
+            clientX: 1,
+            clientY: 1,
+            ctrlKey: false,
+            altKey: false,
+            shiftKey: false,
+            metaKey: false,
+            button: 0,
+            relatedTarget: undefined
+        }, options );
+
+        if ( document.createEvent ) {
+            event = document.createEvent( "MouseEvents" );
+            event.initMouseEvent( type, options.bubbles, options.cancelable,
+                options.view, options.detail,
+                options.screenX, options.screenY, options.clientX, options.clientY,
+                options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,
+                options.button, options.relatedTarget || document.body.parentNode );
+
+            // IE 9+ creates events with pageX and pageY set to 0.
+            // Trying to modify the properties throws an error,
+            // so we define getters to return the correct values.
+            if ( event.pageX === 0 && event.pageY === 0 && Object.defineProperty ) {
+                eventDoc = event.relatedTarget.ownerDocument || document;
+                doc = eventDoc.documentElement;
+                body = eventDoc.body;
+
+                Object.defineProperty( event, "pageX", {
+                    get: function() {
+                        return options.clientX +
+                            ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) -
+                            ( doc && doc.clientLeft || body && body.clientLeft || 0 );
+                    }
+                });
+                Object.defineProperty( event, "pageY", {
+                    get: function() {
+                        return options.clientY +
+                            ( doc && doc.scrollTop || body && body.scrollTop || 0 ) -
+                            ( doc && doc.clientTop || body && body.clientTop || 0 );
+                    }
+                });
+            }
+        } else if ( document.createEventObject ) {
+            event = document.createEventObject();
+            $.extend( event, options );
+            // standards event.button uses constants defined here: http://msdn.microsoft.com/en-us/library/ie/ff974877(v=vs.85).aspx
+            // old IE event.button uses constants defined here: http://msdn.microsoft.com/en-us/library/ie/ms533544(v=vs.85).aspx
+            // so we actually need to map the standard back to oldIE
+            event.button = {
+                0: 1,
+                1: 4,
+                2: 2
+            }[ event.button ] || ( event.button === -1 ? 0 : event.button );
+        }
+
+        return event;
+    },
+
+    keyEvent: function( type, options ) {
+        var event;
+        options = $.extend({
+            bubbles: true,
+            cancelable: true,
+            view: window,
+            ctrlKey: false,
+            altKey: false,
+            shiftKey: false,
+            metaKey: false,
+            keyCode: 0,
+            charCode: undefined
+        }, options );
+
+        if ( document.createEvent ) {
+            try {
+                event = document.createEvent( "KeyEvents" );
+                event.initKeyEvent( type, options.bubbles, options.cancelable, options.view,
+                    options.ctrlKey, options.altKey, options.shiftKey, options.metaKey,
+                    options.keyCode, options.charCode );
+            // initKeyEvent throws an exception in WebKit
+            // see: http://stackoverflow.com/questions/6406784/initkeyevent-keypress-only-works-in-firefox-need-a-cross-browser-solution
+            // and also https://bugs.webkit.org/show_bug.cgi?id=13368
+            // fall back to a generic event until we decide to implement initKeyboardEvent
+            } catch( err ) {
+                event = document.createEvent( "Events" );
+                event.initEvent( type, options.bubbles, options.cancelable );
+                $.extend( event, {
+                    view: options.view,
+                    ctrlKey: options.ctrlKey,
+                    altKey: options.altKey,
+                    shiftKey: options.shiftKey,
+                    metaKey: options.metaKey,
+                    keyCode: options.keyCode,
+                    charCode: options.charCode
+                });
+            }
+        } else if ( document.createEventObject ) {
+            event = document.createEventObject();
+            $.extend( event, options );
+        }
+
+        if ( !!/msie [\w.]+/.exec( navigator.userAgent.toLowerCase() ) || (({}).toString.call( window.opera ) === "[object Opera]") ) {
+            event.keyCode = (options.charCode > 0) ? options.charCode : options.keyCode;
+            event.charCode = undefined;
+        }
+
+        return event;
+    },
+
+    dispatchEvent: function( elem, type, event ) {
+        if ( elem.dispatchEvent ) {
+            elem.dispatchEvent( event );
+        } else if ( type === "click" && elem.click && elem.nodeName.toLowerCase() === "input" ) {
+            elem.click();
+        } else if ( elem.fireEvent ) {
+            elem.fireEvent( "on" + type, event );
+        }
+    },
+
+    simulateFocus: function() {
+        var focusinEvent,
+            triggered = false,
+            element = $( this.target );
+
+        function trigger() {
+            triggered = true;
+        }
+
+        element.bind( "focus", trigger );
+        element[ 0 ].focus();
+
+        if ( !triggered ) {
+            focusinEvent = $.Event( "focusin" );
+            focusinEvent.preventDefault();
+            element.trigger( focusinEvent );
+            element.triggerHandler( "focus" );
+        }
+        element.unbind( "focus", trigger );
+    },
+
+    simulateBlur: function() {
+        var focusoutEvent,
+            triggered = false,
+            element = $( this.target );
+
+        function trigger() {
+            triggered = true;
+        }
+
+        element.bind( "blur", trigger );
+        element[ 0 ].blur();
+
+        // blur events are async in IE
+        setTimeout(function() {
+            // IE won't let the blur occur if the window is inactive
+            if ( element[ 0 ].ownerDocument.activeElement === element[ 0 ] ) {
+                element[ 0 ].ownerDocument.body.focus();
+            }
+
+            // Firefox won't trigger events if the window is inactive
+            // IE doesn't trigger events if we had to manually focus the body
+            if ( !triggered ) {
+                focusoutEvent = $.Event( "focusout" );
+                focusoutEvent.preventDefault();
+                element.trigger( focusoutEvent );
+                element.triggerHandler( "blur" );
+            }
+            element.unbind( "blur", trigger );
+        }, 1 );
+    }
+});
+
+
+
+/** complex events **/
+
+function findCenter( elem ) {
+    var offset,
+        document = $( elem.ownerDocument );
+    elem = $( elem );
+    offset = elem.offset();
+
+    return {
+        x: offset.left + elem.outerWidth() / 2 - document.scrollLeft(),
+        y: offset.top + elem.outerHeight() / 2 - document.scrollTop()
+    };
+}
+
+function findCorner( elem ) {
+    var offset,
+        document = $( elem.ownerDocument );
+    elem = $( elem );
+    offset = elem.offset();
+
+    return {
+        x: offset.left - document.scrollLeft(),
+        y: offset.top - document.scrollTop()
+    };
+}
+
+$.extend( $.simulate.prototype, {
+    simulateDrag: function() {
+        var i = 0,
+            target = this.target,
+            eventDoc = target.ownerDocument,
+            options = this.options,
+            center = options.handle === "corner" ? findCorner( target ) : findCenter( target ),
+            x = Math.floor( center.x ),
+            y = Math.floor( center.y ),
+            coord = { clientX: x, clientY: y },
+            dx = options.dx || ( options.x !== undefined ? options.x - x : 0 ),
+            dy = options.dy || ( options.y !== undefined ? options.y - y : 0 ),
+            moves = options.moves || 3;
+
+        this.simulateEvent( target, "mousedown", coord );
+
+        for ( ; i < moves ; i++ ) {
+            x += dx / moves;
+            y += dy / moves;
+
+            coord = {
+                clientX: Math.round( x ),
+                clientY: Math.round( y )
+            };
+
+            this.simulateEvent( eventDoc, "mousemove", coord );
+        }
+
+        if ( $.contains( eventDoc, target ) ) {
+            this.simulateEvent( target, "mouseup", coord );
+            this.simulateEvent( target, "click", coord );
+        } else {
+            this.simulateEvent( eventDoc, "mouseup", coord );
+        }
+    }
+});
+
+})( jQuery );