app/jquery/jquery-ui.core.js

   1 /*
   2  * jQuery UI @VERSION
   3  *
   4  * Copyright (c) 2009 AUTHORS.txt (http://ui.jquery.com/about)
   5  * Dual licensed under the MIT (MIT-LICENSE.txt)
   6  * and GPL (GPL-LICENSE.txt) licenses.
   7  *
   8  * http://docs.jquery.com/UI
   9  */
  10 ;(function($) {
  11
  12 var _remove = $.fn.remove,
  13         isFF2 = $.browser.mozilla && (parseFloat($.browser.version) < 1.9);
  14
  15 //Helper functions and ui object
  16 $.ui = {
  17         version: "@VERSION",
  18
  19         // $.ui.plugin is deprecated.  Use the proxy pattern instead.
  20         plugin: {
  21                 add: function(module, option, set) {
  22                         var proto = $.ui[module].prototype;
  23                         for(var i in set) {
  24                                 proto.plugins[i] = proto.plugins[i] || [];
  25                                 proto.plugins[i].push([option, set[i]]);
  26                         }
  27                 },
  28                 call: function(instance, name, args) {
  29                         var set = instance.plugins[name];
  30                         if(!set) { return; }
  31
  32                         for (var i = 0; i < set.length; i++) {
  33                                 if (instance.options[set[i][0]]) {
  34                                         set[i][1].apply(instance.element, args);
  35                                 }
  36                         }
  37                 }
  38         },
  39
  40         contains: function(a, b) {
  41                 return document.compareDocumentPosition
  42                         ? a.compareDocumentPosition(b) & 16
  43                         : a !== b && a.contains(b);
  44         },
  45
  46         cssCache: {},
  47         css: function(name) {
  48                 if ($.ui.cssCache[name]) { return $.ui.cssCache[name]; }
  49                 var tmp = $('<div class="ui-gen"></div>').addClass(name).css({position:'absolute', top:'-5000px', left:'-5000px', display:'block'}).appendTo('body');
  50
  51                 //if (!$.browser.safari)
  52                         //tmp.appendTo('body');
  53
  54                 //Opera and Safari set width and height to 0px instead of auto
  55                 //Safari returns rgba(0,0,0,0) when bgcolor is not set
  56                 $.ui.cssCache[name] = !!(
  57                         (!(/auto|default/).test(tmp.css('cursor')) || (/^[1-9]/).test(tmp.css('height')) || (/^[1-9]/).test(tmp.css('width')) ||
  58                         !(/none/).test(tmp.css('backgroundImage')) || !(/transparent|rgba\(0, 0, 0, 0\)/).test(tmp.css('backgroundColor')))
  59                 );
  60                 try { $('body').get(0).removeChild(tmp.get(0)); } catch(e){}
  61                 return $.ui.cssCache[name];
  62         },
  63
  64         hasScroll: function(el, a) {
  65
  66                 //If overflow is hidden, the element might have extra content, but the user wants to hide it
  67                 if ($(el).css('overflow') == 'hidden') { return false; }
  68
  69                 var scroll = (a && a == 'left') ? 'scrollLeft' : 'scrollTop',
  70                         has = false;
  71
  72                 if (el[scroll] > 0) { return true; }
  73
  74                 // TODO: determine which cases actually cause this to happen
  75                 // if the element doesn't have the scroll set, see if it's possible to
  76                 // set the scroll
  77                 el[scroll] = 1;
  78                 has = (el[scroll] > 0);
  79                 el[scroll] = 0;
  80                 return has;
  81         },
  82
  83         isOverAxis: function(x, reference, size) {
  84                 //Determines when x coordinate is over "b" element axis
  85                 return (x > reference) && (x < (reference + size));
  86         },
  87
  88         isOver: function(y, x, top, left, height, width) {
  89                 //Determines when x, y coordinates is over "b" element
  90                 return $.ui.isOverAxis(y, top, height) && $.ui.isOverAxis(x, left, width);
  91         },
  92
  93         keyCode: {
  94                 BACKSPACE: 8,
  95                 CAPS_LOCK: 20,
  96                 COMMA: 188,
  97                 CONTROL: 17,
  98                 DELETE: 46,
  99                 DOWN: 40,
 100                 END: 35,
 101                 ENTER: 13,
 102                 ESCAPE: 27,
 103                 HOME: 36,
 104                 INSERT: 45,
 105                 LEFT: 37,
 106                 NUMPAD_ADD: 107,
 107                 NUMPAD_DECIMAL: 110,
 108                 NUMPAD_DIVIDE: 111,
 109                 NUMPAD_ENTER: 108,
 110                 NUMPAD_MULTIPLY: 106,
 111                 NUMPAD_SUBTRACT: 109,
 112                 PAGE_DOWN: 34,
 113                 PAGE_UP: 33,
 114                 PERIOD: 190,
 115                 RIGHT: 39,
 116                 SHIFT: 16,
 117                 SPACE: 32,
 118                 TAB: 9,
 119                 UP: 38
 120         }
 121 };
 122
 123 // WAI-ARIA normalization
 124 if (isFF2) {
 125         var attr = $.attr,
 126                 removeAttr = $.fn.removeAttr,
 127                 ariaNS = "http://www.w3.org/2005/07/aaa",
 128                 ariaState = /^aria-/,
 129                 ariaRole = /^wairole:/;
 130
 131         $.attr = function(elem, name, value) {
 132                 var set = value !== undefined;
 133
 134                 return (name == 'role'
 135                         ? (set
 136                                 ? attr.call(this, elem, name, "wairole:" + value)
 137                                 : (attr.apply(this, arguments) || "").replace(ariaRole, ""))
 138                         : (ariaState.test(name)
 139                                 ? (set
 140                                         ? elem.setAttributeNS(ariaNS,
 141                                                 name.replace(ariaState, "aaa:"), value)
 142                                         : attr.call(this, elem, name.replace(ariaState, "aaa:")))
 143                                 : attr.apply(this, arguments)));
 144         };
 145
 146         $.fn.removeAttr = function(name) {
 147                 return (ariaState.test(name)
 148                         ? this.each(function() {
 149                                 this.removeAttributeNS(ariaNS, name.replace(ariaState, ""));
 150                         }) : removeAttr.call(this, name));
 151         };
 152 }
 153
 154 //jQuery plugins
 155 $.fn.extend({
 156         remove: function() {
 157                 // Safari has a native remove event which actually removes DOM elements,
 158                 // so we have to use triggerHandler instead of trigger (#3037).
 159                 $("*", this).add(this).each(function() {
 160                         $(this).triggerHandler("remove");
 161                 });
 162                 return _remove.apply(this, arguments );
 163         },
 164
 165         enableSelection: function() {
 166                 return this
 167                         .attr('unselectable', 'off')
 168                         .css('MozUserSelect', '')
 169                         .unbind('selectstart.ui');
 170         },
 171
 172         disableSelection: function() {
 173                 return this
 174                         .attr('unselectable', 'on')
 175                         .css('MozUserSelect', 'none')
 176                         .bind('selectstart.ui', function() { return false; });
 177         },
 178
 179         scrollParent: function() {
 180                 var scrollParent;
 181                 if(($.browser.msie && (/(static|relative)/).test(this.css('position'))) || (/absolute/).test(this.css('position'))) {
 182                         scrollParent = this.parents().filter(function() {
 183                                 return (/(relative|absolute|fixed)/).test($.curCSS(this,'position',1)) && (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
 184                         }).eq(0);
 185                 } else {
 186                         scrollParent = this.parents().filter(function() {
 187                                 return (/(auto|scroll)/).test($.curCSS(this,'overflow',1)+$.curCSS(this,'overflow-y',1)+$.curCSS(this,'overflow-x',1));
 188                         }).eq(0);
 189                 }
 190
 191                 return (/fixed/).test(this.css('position')) || !scrollParent.length ? $(document) : scrollParent;
 192         }
 193 });
 194
 195
 196 //Additional selectors
 197 $.extend($.expr[':'], {
 198         data: function(elem, i, match) {
 199                 return !!$.data(elem, match[3]);
 200         },
 201
 202         // TODO: add support for object, area
 203         tabbable: function(elem) {
 204                 var nodeName = elem.nodeName.toLowerCase();
 205                 function isVisible(element) {
 206                         return !($(element).is(':hidden') || $(element).parents(':hidden').length);
 207                 }
 208
 209                 return (
 210                         // in tab order
 211                         elem.tabIndex >= 0 &&
 212
 213                         ( // filter node types that participate in the tab order
 214
 215                                 // anchor tag
 216                                 ('a' == nodeName && elem.href) ||
 217
 218                                 // enabled form element
 219                                 (/input|select|textarea|button/.test(nodeName) &&
 220                                         'hidden' != elem.type && !elem.disabled)
 221                         ) &&
 222
 223                         // visible on page
 224                         isVisible(elem)
 225                 );
 226         }
 227 });
 228
 229
 230 // $.widget is a factory to create jQuery plugins
 231 // taking some boilerplate code out of the plugin code
 232 function getter(namespace, plugin, method, args) {
 233         function getMethods(type) {
 234                 var methods = $[namespace][plugin][type] || [];
 235                 return (typeof methods == 'string' ? methods.split(/,?\s+/) : methods);
 236         }
 237
 238         var methods = getMethods('getter');
 239         if (args.length == 1 && typeof args[0] == 'string') {
 240                 methods = methods.concat(getMethods('getterSetter'));
 241         }
 242         return ($.inArray(method, methods) != -1);
 243 }
 244
 245 $.widget = function(name, prototype) {
 246         var namespace = name.split(".")[0];
 247         name = name.split(".")[1];
 248
 249         // create plugin method
 250         $.fn[name] = function(options) {
 251                 var isMethodCall = (typeof options == 'string'),
 252                         args = Array.prototype.slice.call(arguments, 1);
 253
 254                 // prevent calls to internal methods
 255                 if (isMethodCall && options.substring(0, 1) == '_') {
 256                         return this;
 257                 }
 258
 259                 // handle getter methods
 260                 if (isMethodCall && getter(namespace, name, options, args)) {
 261                         var instance = $.data(this[0], name);
 262                         return (instance ? instance[options].apply(instance, args)
 263                                 : undefined);
 264                 }
 265
 266                 // handle initialization and non-getter methods
 267                 return this.each(function() {
 268                         var instance = $.data(this, name);
 269
 270                         // constructor
 271                         (!instance && !isMethodCall &&
 272                                 $.data(this, name, new $[namespace][name](this, options)));
 273
 274                         // method call
 275                         (instance && isMethodCall && $.isFunction(instance[options]) &&
 276                                 instance[options].apply(instance, args));
 277                 });
 278         };
 279
 280         // create widget constructor
 281         $[namespace] = $[namespace] || {};
 282         $[namespace][name] = function(element, options) {
 283                 var self = this;
 284
 285                 this.namespace = namespace;
 286                 this.widgetName = name;
 287                 this.widgetEventPrefix = $[namespace][name].eventPrefix || name;
 288                 this.widgetBaseClass = namespace + '-' + name;
 289
 290                 this.options = $.extend({},
 291                         $.widget.defaults,
 292                         $[namespace][name].defaults,
 293                         $.metadata && $.metadata.get(element)[name],
 294                         options);
 295
 296                 this.element = $(element)
 297                         .bind('setData.' + name, function(event, key, value) {
 298                                 if (event.target == element) {
 299                                         return self._setData(key, value);
 300                                 }
 301                         })
 302                         .bind('getData.' + name, function(event, key) {
 303                                 if (event.target == element) {
 304                                         return self._getData(key);
 305                                 }
 306                         })
 307                         .bind('remove', function() {
 308                                 return self.destroy();
 309                         });
 310
 311                 this._init();
 312         };
 313
 314         // add widget prototype
 315         $[namespace][name].prototype = $.extend({}, $.widget.prototype, prototype);
 316
 317         // TODO: merge getter and getterSetter properties from widget prototype
 318         // and plugin prototype
 319         $[namespace][name].getterSetter = 'option';
 320 };
 321
 322 $.widget.prototype = {
 323         _init: function() {},
 324         destroy: function() {
 325                 this.element.removeData(this.widgetName)
 326                         .removeClass(this.widgetBaseClass + '-disabled' + ' ' + this.namespace + '-state-disabled')
 327                         .removeAttr('aria-disabled');
 328         },
 329
 330         option: function(key, value) {
 331                 var options = key,
 332                         self = this;
 333
 334                 if (typeof key == "string") {
 335                         if (value === undefined) {
 336                                 return this._getData(key);
 337                         }
 338                         options = {};
 339                         options[key] = value;
 340                 }
 341
 342                 $.each(options, function(key, value) {
 343                         self._setData(key, value);
 344                 });
 345         },
 346         _getData: function(key) {
 347                 return this.options[key];
 348         },
 349         _setData: function(key, value) {
 350                 this.options[key] = value;
 351
 352                 if (key == 'disabled') {
 353                         this.element
 354                                 [value ? 'addClass' : 'removeClass'](
 355                                         this.widgetBaseClass + '-disabled' + ' ' +
 356                                         this.namespace + '-state-disabled')
 357                                 .attr("aria-disabled", value);
 358                 }
 359         },
 360
 361         enable: function() {
 362                 this._setData('disabled', false);
 363         },
 364         disable: function() {
 365                 this._setData('disabled', true);
 366         },
 367
 368         _trigger: function(type, event, data) {
 369                 var callback = this.options[type],
 370                         eventName = (type == this.widgetEventPrefix
 371                                 ? type : this.widgetEventPrefix + type);
 372
 373                 event = event ? $.event.fix(event) : $.Event();
 374                 event.type = eventName;
 375
 376                 this.element.trigger(event, data);
 377
 378                 return !(callback && callback.call(this.element[0], event, data) === false
 379                         || event.isDefaultPrevented());
 380         }
 381 };
 382
 383 $.widget.defaults = {
 384         disabled: false
 385 };
 386
 387
 388 /** Mouse Interaction Plugin **/
 389
 390 $.ui.mouse = {
 391         _mouseInit: function() {
 392                 var self = this;
 393
 394                 this.element
 395                         .bind('mousedown.'+this.widgetName, function(event) {
 396                                 return self._mouseDown(event);
 397                         })
 398                         .bind('click.'+this.widgetName, function(event) {
 399                                 if(self._preventClickEvent) {
 400                                         self._preventClickEvent = false;
 401                                         return false;
 402                                 }
 403                         });
 404
 405                 // Prevent text selection in IE
 406                 if ($.browser.msie) {
 407                         this._mouseUnselectable = this.element.attr('unselectable');
 408                         this.element.attr('unselectable', 'on');
 409                 }
 410
 411                 this.started = false;
 412         },
 413
 414         // TODO: make sure destroying one instance of mouse doesn't mess with
 415         // other instances of mouse
 416         _mouseDestroy: function() {
 417                 this.element.unbind('.'+this.widgetName);
 418
 419                 // Restore text selection in IE
 420                 ($.browser.msie
 421                         && this.element.attr('unselectable', this._mouseUnselectable));
 422         },
 423
 424         _mouseDown: function(event) {
 425                 // we may have missed mouseup (out of window)
 426                 (this._mouseStarted && this._mouseUp(event));
 427
 428                 this._mouseDownEvent = event;
 429
 430                 var self = this,
 431                         btnIsLeft = (event.which == 1),
 432                         elIsCancel = (typeof this.options.cancel == "string" ? $(event.target).parents().add(event.target).filter(this.options.cancel).length : false);
 433                 if (!btnIsLeft || elIsCancel || !this._mouseCapture(event)) {
 434                         return true;
 435                 }
 436
 437                 this.mouseDelayMet = !this.options.delay;
 438                 if (!this.mouseDelayMet) {
 439                         this._mouseDelayTimer = setTimeout(function() {
 440                                 self.mouseDelayMet = true;
 441                         }, this.options.delay);
 442                 }
 443
 444                 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 445                         this._mouseStarted = (this._mouseStart(event) !== false);
 446                         if (!this._mouseStarted) {
 447                                 event.preventDefault();
 448                                 return true;
 449                         }
 450                 }
 451
 452                 // these delegates are required to keep context
 453                 this._mouseMoveDelegate = function(event) {
 454                         return self._mouseMove(event);
 455                 };
 456                 this._mouseUpDelegate = function(event) {
 457                         return self._mouseUp(event);
 458                 };
 459                 $(document)
 460                         .bind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
 461                         .bind('mouseup.'+this.widgetName, this._mouseUpDelegate);
 462
 463                 // preventDefault() is used to prevent the selection of text here -
 464                 // however, in Safari, this causes select boxes not to be selectable
 465                 // anymore, so this fix is needed
 466                 ($.browser.safari || event.preventDefault());
 467
 468                 return true;
 469         },
 470
 471         _mouseMove: function(event) {
 472                 // IE mouseup check - mouseup happened when mouse was out of window
 473                 if ($.browser.msie && !event.button) {
 474                         return this._mouseUp(event);
 475                 }
 476
 477                 if (this._mouseStarted) {
 478                         this._mouseDrag(event);
 479                         return event.preventDefault();
 480                 }
 481
 482                 if (this._mouseDistanceMet(event) && this._mouseDelayMet(event)) {
 483                         this._mouseStarted =
 484                                 (this._mouseStart(this._mouseDownEvent, event) !== false);
 485                         (this._mouseStarted ? this._mouseDrag(event) : this._mouseUp(event));
 486                 }
 487
 488                 return !this._mouseStarted;
 489         },
 490
 491         _mouseUp: function(event) {
 492                 $(document)
 493                         .unbind('mousemove.'+this.widgetName, this._mouseMoveDelegate)
 494                         .unbind('mouseup.'+this.widgetName, this._mouseUpDelegate);
 495
 496                 if (this._mouseStarted) {
 497                         this._mouseStarted = false;
 498                         this._preventClickEvent = true;
 499                         this._mouseStop(event);
 500                 }
 501
 502                 return false;
 503         },
 504
 505         _mouseDistanceMet: function(event) {
 506                 return (Math.max(
 507                                 Math.abs(this._mouseDownEvent.pageX - event.pageX),
 508                                 Math.abs(this._mouseDownEvent.pageY - event.pageY)
 509                         ) >= this.options.distance
 510                 );
 511         },
 512
 513         _mouseDelayMet: function(event) {
 514                 return this.mouseDelayMet;
 515         },
 516
 517         // These are placeholder methods, to be overriden by extending plugin
 518         _mouseStart: function(event) {},
 519         _mouseDrag: function(event) {},
 520         _mouseStop: function(event) {},
 521         _mouseCapture: function(event) { return true; }
 522 };
 523
 524 $.ui.mouse.defaults = {
 525         cancel: null,
 526         distance: 1,
 527         delay: 0
 528 };
 529
 530 })(jQuery);