src/event/event.js

   1 jQuery.fn.extend({
   2
   3         // We're overriding the old toggle function, so
   4         // remember it for later
   5         _toggle: jQuery.fn.toggle,
   6
   7         /**
   8          * Toggle between two function calls every other click.
   9          * Whenever a matched element is clicked, the first specified function
  10          * is fired, when clicked again, the second is fired. All subsequent
  11          * clicks continue to rotate through the two functions.
  12          *
  13          * @example $("p").toggle(function(){
  14          *   $(this).addClass("selected");
  15          * },function(){
  16          *   $(this).removeClass("selected");
  17          * });
  18          *
  19          * var count = 0;
  20          * var fn1 = function() { count++; }
  21          * var fn2 = function() { count--; }
  22          * var link = $('#mark');
  23          * link.click().toggle(fn1, fn2).click().click().click().click().click();
  24          * ok( count == 1, "Check for toggle(fn, fn)" );
  25          *
  26          * @name toggle
  27          * @type jQuery
  28          * @param Function even The function to execute on every even click.
  29          * @param Function odd The function to execute on every odd click.
  30          * @cat Events
  31          */
  32         toggle: function(a,b) {
  33                 // If two functions are passed in, we're
  34                 // toggling on a click
  35                 return a && b && a.constructor == Function && b.constructor == Function ? this.click(function(e){
  36                         // Figure out which function to execute
  37                         this.last = this.last == a ? b : a;
  38
  39                         // Make sure that clicks stop
  40                         e.preventDefault();
  41
  42                         // and execute the function
  43                         return this.last.apply( this, [e] ) || false;
  44                 }) :
  45
  46                 // Otherwise, execute the old toggle function
  47                 this._toggle.apply( this, arguments );
  48         },
  49
  50         /**
  51          * A method for simulating hovering (moving the mouse on, and off,
  52          * an object). This is a custom method which provides an 'in' to a
  53          * frequent task.
  54          *
  55          * Whenever the mouse cursor is moved over a matched
  56          * element, the first specified function is fired. Whenever the mouse
  57          * moves off of the element, the second specified function fires.
  58          * Additionally, checks are in place to see if the mouse is still within
  59          * the specified element itself (for example, an image inside of a div),
  60          * and if it is, it will continue to 'hover', and not move out
  61          * (a common error in using a mouseout event handler).
  62          *
  63          * @example $("p").hover(function(){
  64          *   $(this).addClass("over");
  65          * },function(){
  66          *   $(this).addClass("out");
  67          * });
  68          *
  69          * @name hover
  70          * @type jQuery
  71          * @param Function over The function to fire whenever the mouse is moved over a matched element.
  72          * @param Function out The function to fire whenever the mouse is moved off of a matched element.
  73          * @cat Events
  74          */\r
  75         hover: function(f,g) {
  76
  77                 // A private function for haandling mouse 'hovering'
  78                 function handleHover(e) {
  79                         // Check if mouse(over|out) are still within the same parent element
  80                         var p = (e.type == "mouseover" ? e.fromElement : e.toElement) || e.relatedTarget;
  81
  82                         // Traverse up the tree
  83                         while ( p && p != this ) p = p.parentNode;
  84
  85                         // If we actually just moused on to a sub-element, ignore it
  86                         if ( p == this ) return false;
  87
  88                         // Execute the right function
  89                         return (e.type == "mouseover" ? f : g).apply(this, [e]);
  90                 }
  91
  92                 // Bind the function to the two event listeners
  93                 return this.mouseover(handleHover).mouseout(handleHover);
  94         },
  95
  96         /**
  97          * Bind a function to be executed whenever the DOM is ready to be
  98          * traversed and manipulated. This is probably the most important
  99          * function included in the event module, as it can greatly improve
 100          * the response times of your web applications.
 101          *
 102          * In a nutshell, this is a solid replacement for using window.onload,
 103          * and attaching a function to that. By using this method, your bound Function
 104          * will be called the instant the DOM is ready to be read and manipulated,
 105          * which is exactly what 99.99% of all Javascript code needs to run.
 106          *
 107          * Please ensure you have no code in your &lt;body&gt; onload event handler,
 108          * otherwise $(document).ready() may not fire.
 109          *
 110          * @example $(document).ready(function(){ Your code here... });
 111          *
 112          * @name ready
 113          * @type jQuery
 114          * @param Function fn The function to be executed when the DOM is ready.
 115          * @cat Events
 116          */
 117         ready: function(f) {
 118                 // If the DOM is already ready
 119                 if ( jQuery.isReady )
 120                         // Execute the function immediately
 121                         f.apply( document );
 122
 123                 // Otherwise, remember the function for later
 124                 else {
 125                         // Add the function to the wait list
 126                         jQuery.readyList.push( f );
 127                 }
 128
 129                 return this;
 130         }
 131 });
 132
 133 jQuery.extend({
 134         /*
 135          * All the code that makes DOM Ready work nicely.
 136          */
 137         isReady: false,
 138         readyList: [],
 139
 140         // Handle when the DOM is ready
 141         ready: function() {
 142                 // Make sure that the DOM is not already loaded
 143                 if ( !jQuery.isReady ) {
 144                         // Remember that the DOM is ready
 145                         jQuery.isReady = true;
 146
 147                         // If there are functions bound, to execute
 148                         if ( jQuery.readyList ) {
 149                                 // Execute all of them
 150                                 for ( var i = 0; i < jQuery.readyList.length; i++ )
 151                                         jQuery.readyList[i].apply( document );
 152
 153                                 // Reset the list of functions
 154                                 jQuery.readyList = null;
 155                         }
 156                 }
 157         }
 158 });
 159
 160 new function(){
 161
 162                 /**
 163                  * Bind a function to the scroll event of each matched element.
 164                  *
 165                  * @example $("p").scroll( function() { alert("Hello"); } );
 166                  * @before <p>Hello</p>
 167                  * @result <p onscroll="alert('Hello');">Hello</p>
 168                  *
 169                  * @name scroll
 170                  * @type jQuery
 171                  * @param Function fn A function to bind to the scroll event on each of the matched elements.
 172                  * @cat Events/Browser
 173                  */
 174
 175                 /**
 176                  * Trigger the scroll event of each matched element. This causes all of the functions
 177                  * that have been bound to thet scroll event to be executed.
 178                  *
 179                  * @example $("p").scroll();
 180                  * @before <p onscroll="alert('Hello');">Hello</p>
 181                  * @result alert('Hello');
 182                  *
 183                  * @name scroll
 184                  * @type jQuery
 185                  * @cat Events/Browser
 186                  */
 187
 188                 /**
 189                  * Bind a function to the scroll event of each matched element, which will only be executed once.
 190                  * Unlike a call to the normal .scroll() method, calling .onescroll() causes the bound function to be
 191                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 192                  *
 193                  * @example $("p").onescroll( function() { alert("Hello"); } );
 194                  * @before <p onscroll="alert('Hello');">Hello</p>
 195                  * @result alert('Hello'); // Only executed for the first scroll
 196                  *
 197                  * @name onescroll
 198                  * @type jQuery
 199                  * @param Function fn A function to bind to the scroll event on each of the matched elements.
 200                  * @cat Events/Browser
 201                  */
 202
 203                 /**
 204                  * Removes a bound scroll event from each of the matched
 205                  * elements. You must pass the identical function that was used in the original
 206                  * bind method.
 207                  *
 208                  * @example $("p").unscroll( myFunction );
 209                  * @before <p onscroll="myFunction">Hello</p>
 210                  * @result <p>Hello</p>
 211                  *
 212                  * @name unscroll
 213                  * @type jQuery
 214                  * @param Function fn A function to unbind from the scroll event on each of the matched elements.
 215                  * @cat Events/Browser
 216                  */
 217
 218                 /**
 219                  * Removes all bound scroll events from each of the matched elements.
 220                  *
 221                  * @example $("p").unscroll();
 222                  * @before <p onscroll="alert('Hello');">Hello</p>
 223                  * @result <p>Hello</p>
 224                  *
 225                  * @name unscroll
 226                  * @type jQuery
 227                  * @cat Events/Browser
 228                  */
 229
 230                 /**
 231                  * Bind a function to the submit event of each matched element.
 232                  *
 233                  * @example $("p").submit( function() { alert("Hello"); } );
 234                  * @before <p>Hello</p>
 235                  * @result <p onsubmit="alert('Hello');">Hello</p>
 236                  *
 237                  * @name submit
 238                  * @type jQuery
 239                  * @param Function fn A function to bind to the submit event on each of the matched elements.
 240                  * @cat Events/Form
 241                  */
 242
 243                 /**
 244                  * Trigger the submit event of each matched element. This causes all of the functions
 245                  * that have been bound to thet submit event to be executed.
 246                  *
 247                  * @example $("p").submit();
 248                  * @before <p onsubmit="alert('Hello');">Hello</p>
 249                  * @result alert('Hello');
 250                  *
 251                  * @name submit
 252                  * @type jQuery
 253                  * @cat Events/Form
 254                  */
 255
 256                 /**
 257                  * Bind a function to the submit event of each matched element, which will only be executed once.
 258                  * Unlike a call to the normal .submit() method, calling .onesubmit() causes the bound function to be
 259                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 260                  *
 261                  * @example $("p").onesubmit( function() { alert("Hello"); } );
 262                  * @before <p onsubmit="alert('Hello');">Hello</p>
 263                  * @result alert('Hello'); // Only executed for the first submit
 264                  *
 265                  * @name onesubmit
 266                  * @type jQuery
 267                  * @param Function fn A function to bind to the submit event on each of the matched elements.
 268                  * @cat Events/Form
 269                  */
 270
 271                 /**
 272                  * Removes a bound submit event from each of the matched
 273                  * elements. You must pass the identical function that was used in the original
 274                  * bind method.
 275                  *
 276                  * @example $("p").unsubmit( myFunction );
 277                  * @before <p onsubmit="myFunction">Hello</p>
 278                  * @result <p>Hello</p>
 279                  *
 280                  * @name unsubmit
 281                  * @type jQuery
 282                  * @param Function fn A function to unbind from the submit event on each of the matched elements.
 283                  * @cat Events/Form
 284                  */
 285
 286                 /**
 287                  * Removes all bound submit events from each of the matched elements.
 288                  *
 289                  * @example $("p").unsubmit();
 290                  * @before <p onsubmit="alert('Hello');">Hello</p>
 291                  * @result <p>Hello</p>
 292                  *
 293                  * @name unsubmit
 294                  * @type jQuery
 295                  * @cat Events/Form
 296                  */
 297
 298                 /**
 299                  * Bind a function to the focus event of each matched element.
 300                  *
 301                  * @example $("p").focus( function() { alert("Hello"); } );
 302                  * @before <p>Hello</p>
 303                  * @result <p onfocus="alert('Hello');">Hello</p>
 304                  *
 305                  * @name focus
 306                  * @type jQuery
 307                  * @param Function fn A function to bind to the focus event on each of the matched elements.
 308                  * @cat Events/UI
 309                  */
 310
 311                 /**
 312                  * Trigger the focus event of each matched element. This causes all of the functions
 313                  * that have been bound to thet focus event to be executed.
 314                  *
 315                  * @example $("p").focus();
 316                  * @before <p onfocus="alert('Hello');">Hello</p>
 317                  * @result alert('Hello');
 318                  *
 319                  * @name focus
 320                  * @type jQuery
 321                  * @cat Events/UI
 322                  */
 323
 324                 /**
 325                  * Bind a function to the focus event of each matched element, which will only be executed once.
 326                  * Unlike a call to the normal .focus() method, calling .onefocus() causes the bound function to be
 327                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 328                  *
 329                  * @example $("p").onefocus( function() { alert("Hello"); } );
 330                  * @before <p onfocus="alert('Hello');">Hello</p>
 331                  * @result alert('Hello'); // Only executed for the first focus
 332                  *
 333                  * @name onefocus
 334                  * @type jQuery
 335                  * @param Function fn A function to bind to the focus event on each of the matched elements.
 336                  * @cat Events/UI
 337                  */
 338
 339                 /**
 340                  * Removes a bound focus event from each of the matched
 341                  * elements. You must pass the identical function that was used in the original
 342                  * bind method.
 343                  *
 344                  * @example $("p").unfocus( myFunction );
 345                  * @before <p onfocus="myFunction">Hello</p>
 346                  * @result <p>Hello</p>
 347                  *
 348                  * @name unfocus
 349                  * @type jQuery
 350                  * @param Function fn A function to unbind from the focus event on each of the matched elements.
 351                  * @cat Events/UI
 352                  */
 353
 354                 /**
 355                  * Removes all bound focus events from each of the matched elements.
 356                  *
 357                  * @example $("p").unfocus();
 358                  * @before <p onfocus="alert('Hello');">Hello</p>
 359                  * @result <p>Hello</p>
 360                  *
 361                  * @name unfocus
 362                  * @type jQuery
 363                  * @cat Events/UI
 364                  */
 365
 366                 /**
 367                  * Bind a function to the keydown event of each matched element.
 368                  *
 369                  * @example $("p").keydown( function() { alert("Hello"); } );
 370                  * @before <p>Hello</p>
 371                  * @result <p onkeydown="alert('Hello');">Hello</p>
 372                  *
 373                  * @name keydown
 374                  * @type jQuery
 375                  * @param Function fn A function to bind to the keydown event on each of the matched elements.
 376                  * @cat Events/Keyboard
 377                  */
 378
 379                 /**
 380                  * Trigger the keydown event of each matched element. This causes all of the functions
 381                  * that have been bound to thet keydown event to be executed.
 382                  *
 383                  * @example $("p").keydown();
 384                  * @before <p onkeydown="alert('Hello');">Hello</p>
 385                  * @result alert('Hello');
 386                  *
 387                  * @name keydown
 388                  * @type jQuery
 389                  * @cat Events/Keyboard
 390                  */
 391
 392                 /**
 393                  * Bind a function to the keydown event of each matched element, which will only be executed once.
 394                  * Unlike a call to the normal .keydown() method, calling .onekeydown() causes the bound function to be
 395                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 396                  *
 397                  * @example $("p").onekeydown( function() { alert("Hello"); } );
 398                  * @before <p onkeydown="alert('Hello');">Hello</p>
 399                  * @result alert('Hello'); // Only executed for the first keydown
 400                  *
 401                  * @name onekeydown
 402                  * @type jQuery
 403                  * @param Function fn A function to bind to the keydown event on each of the matched elements.
 404                  * @cat Events/Keyboard
 405                  */
 406
 407                 /**
 408                  * Removes a bound keydown event from each of the matched
 409                  * elements. You must pass the identical function that was used in the original
 410                  * bind method.
 411                  *
 412                  * @example $("p").unkeydown( myFunction );
 413                  * @before <p onkeydown="myFunction">Hello</p>
 414                  * @result <p>Hello</p>
 415                  *
 416                  * @name unkeydown
 417                  * @type jQuery
 418                  * @param Function fn A function to unbind from the keydown event on each of the matched elements.
 419                  * @cat Events/Keyboard
 420                  */
 421
 422                 /**
 423                  * Removes all bound keydown events from each of the matched elements.
 424                  *
 425                  * @example $("p").unkeydown();
 426                  * @before <p onkeydown="alert('Hello');">Hello</p>
 427                  * @result <p>Hello</p>
 428                  *
 429                  * @name unkeydown
 430                  * @type jQuery
 431                  * @cat Events/Keyboard
 432                  */
 433
 434                 /**
 435                  * Bind a function to the dblclick event of each matched element.
 436                  *
 437                  * @example $("p").dblclick( function() { alert("Hello"); } );
 438                  * @before <p>Hello</p>
 439                  * @result <p ondblclick="alert('Hello');">Hello</p>
 440                  *
 441                  * @name dblclick
 442                  * @type jQuery
 443                  * @param Function fn A function to bind to the dblclick event on each of the matched elements.
 444                  * @cat Events/Mouse
 445                  */
 446
 447                 /**
 448                  * Trigger the dblclick event of each matched element. This causes all of the functions
 449                  * that have been bound to thet dblclick event to be executed.
 450                  *
 451                  * @example $("p").dblclick();
 452                  * @before <p ondblclick="alert('Hello');">Hello</p>
 453                  * @result alert('Hello');
 454                  *
 455                  * @name dblclick
 456                  * @type jQuery
 457                  * @cat Events/Mouse
 458                  */
 459
 460                 /**
 461                  * Bind a function to the dblclick event of each matched element, which will only be executed once.
 462                  * Unlike a call to the normal .dblclick() method, calling .onedblclick() causes the bound function to be
 463                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 464                  *
 465                  * @example $("p").onedblclick( function() { alert("Hello"); } );
 466                  * @before <p ondblclick="alert('Hello');">Hello</p>
 467                  * @result alert('Hello'); // Only executed for the first dblclick
 468                  *
 469                  * @name onedblclick
 470                  * @type jQuery
 471                  * @param Function fn A function to bind to the dblclick event on each of the matched elements.
 472                  * @cat Events/Mouse
 473                  */
 474
 475                 /**
 476                  * Removes a bound dblclick event from each of the matched
 477                  * elements. You must pass the identical function that was used in the original
 478                  * bind method.
 479                  *
 480                  * @example $("p").undblclick( myFunction );
 481                  * @before <p ondblclick="myFunction">Hello</p>
 482                  * @result <p>Hello</p>
 483                  *
 484                  * @name undblclick
 485                  * @type jQuery
 486                  * @param Function fn A function to unbind from the dblclick event on each of the matched elements.
 487                  * @cat Events/Mouse
 488                  */
 489
 490                 /**
 491                  * Removes all bound dblclick events from each of the matched elements.
 492                  *
 493                  * @example $("p").undblclick();
 494                  * @before <p ondblclick="alert('Hello');">Hello</p>
 495                  * @result <p>Hello</p>
 496                  *
 497                  * @name undblclick
 498                  * @type jQuery
 499                  * @cat Events/Mouse
 500                  */
 501
 502                 /**
 503                  * Bind a function to the keypress event of each matched element.
 504                  *
 505                  * @example $("p").keypress( function() { alert("Hello"); } );
 506                  * @before <p>Hello</p>
 507                  * @result <p onkeypress="alert('Hello');">Hello</p>
 508                  *
 509                  * @name keypress
 510                  * @type jQuery
 511                  * @param Function fn A function to bind to the keypress event on each of the matched elements.
 512                  * @cat Events/Keyboard
 513                  */
 514
 515                 /**
 516                  * Trigger the keypress event of each matched element. This causes all of the functions
 517                  * that have been bound to thet keypress event to be executed.
 518                  *
 519                  * @example $("p").keypress();
 520                  * @before <p onkeypress="alert('Hello');">Hello</p>
 521                  * @result alert('Hello');
 522                  *
 523                  * @name keypress
 524                  * @type jQuery
 525                  * @cat Events/Keyboard
 526                  */
 527
 528                 /**
 529                  * Bind a function to the keypress event of each matched element, which will only be executed once.
 530                  * Unlike a call to the normal .keypress() method, calling .onekeypress() causes the bound function to be
 531                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 532                  *
 533                  * @example $("p").onekeypress( function() { alert("Hello"); } );
 534                  * @before <p onkeypress="alert('Hello');">Hello</p>
 535                  * @result alert('Hello'); // Only executed for the first keypress
 536                  *
 537                  * @name onekeypress
 538                  * @type jQuery
 539                  * @param Function fn A function to bind to the keypress event on each of the matched elements.
 540                  * @cat Events/Keyboard
 541                  */
 542
 543                 /**
 544                  * Removes a bound keypress event from each of the matched
 545                  * elements. You must pass the identical function that was used in the original
 546                  * bind method.
 547                  *
 548                  * @example $("p").unkeypress( myFunction );
 549                  * @before <p onkeypress="myFunction">Hello</p>
 550                  * @result <p>Hello</p>
 551                  *
 552                  * @name unkeypress
 553                  * @type jQuery
 554                  * @param Function fn A function to unbind from the keypress event on each of the matched elements.
 555                  * @cat Events/Keyboard
 556                  */
 557
 558                 /**
 559                  * Removes all bound keypress events from each of the matched elements.
 560                  *
 561                  * @example $("p").unkeypress();
 562                  * @before <p onkeypress="alert('Hello');">Hello</p>
 563                  * @result <p>Hello</p>
 564                  *
 565                  * @name unkeypress
 566                  * @type jQuery
 567                  * @cat Events/Keyboard
 568                  */
 569
 570                 /**
 571                  * Bind a function to the error event of each matched element.
 572                  *
 573                  * @example $("p").error( function() { alert("Hello"); } );
 574                  * @before <p>Hello</p>
 575                  * @result <p onerror="alert('Hello');">Hello</p>
 576                  *
 577                  * @name error
 578                  * @type jQuery
 579                  * @param Function fn A function to bind to the error event on each of the matched elements.
 580                  * @cat Events/Browser
 581                  */
 582
 583                 /**
 584                  * Trigger the error event of each matched element. This causes all of the functions
 585                  * that have been bound to thet error event to be executed.
 586                  *
 587                  * @example $("p").error();
 588                  * @before <p onerror="alert('Hello');">Hello</p>
 589                  * @result alert('Hello');
 590                  *
 591                  * @name error
 592                  * @type jQuery
 593                  * @cat Events/Browser
 594                  */
 595
 596                 /**
 597                  * Bind a function to the error event of each matched element, which will only be executed once.
 598                  * Unlike a call to the normal .error() method, calling .oneerror() causes the bound function to be
 599                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 600                  *
 601                  * @example $("p").oneerror( function() { alert("Hello"); } );
 602                  * @before <p onerror="alert('Hello');">Hello</p>
 603                  * @result alert('Hello'); // Only executed for the first error
 604                  *
 605                  * @name oneerror
 606                  * @type jQuery
 607                  * @param Function fn A function to bind to the error event on each of the matched elements.
 608                  * @cat Events/Browser
 609                  */
 610
 611                 /**
 612                  * Removes a bound error event from each of the matched
 613                  * elements. You must pass the identical function that was used in the original
 614                  * bind method.
 615                  *
 616                  * @example $("p").unerror( myFunction );
 617                  * @before <p onerror="myFunction">Hello</p>
 618                  * @result <p>Hello</p>
 619                  *
 620                  * @name unerror
 621                  * @type jQuery
 622                  * @param Function fn A function to unbind from the error event on each of the matched elements.
 623                  * @cat Events/Browser
 624                  */
 625
 626                 /**
 627                  * Removes all bound error events from each of the matched elements.
 628                  *
 629                  * @example $("p").unerror();
 630                  * @before <p onerror="alert('Hello');">Hello</p>
 631                  * @result <p>Hello</p>
 632                  *
 633                  * @name unerror
 634                  * @type jQuery
 635                  * @cat Events/Browser
 636                  */
 637
 638                 /**
 639                  * Bind a function to the blur event of each matched element.
 640                  *
 641                  * @example $("p").blur( function() { alert("Hello"); } );
 642                  * @before <p>Hello</p>
 643                  * @result <p onblur="alert('Hello');">Hello</p>
 644                  *
 645                  * @name blur
 646                  * @type jQuery
 647                  * @param Function fn A function to bind to the blur event on each of the matched elements.
 648                  * @cat Events/UI
 649                  */
 650
 651                 /**
 652                  * Trigger the blur event of each matched element. This causes all of the functions
 653                  * that have been bound to thet blur event to be executed.
 654                  *
 655                  * @example $("p").blur();
 656                  * @before <p onblur="alert('Hello');">Hello</p>
 657                  * @result alert('Hello');
 658                  *
 659                  * @name blur
 660                  * @type jQuery
 661                  * @cat Events/UI
 662                  */
 663
 664                 /**
 665                  * Bind a function to the blur event of each matched element, which will only be executed once.
 666                  * Unlike a call to the normal .blur() method, calling .oneblur() causes the bound function to be
 667                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 668                  *
 669                  * @example $("p").oneblur( function() { alert("Hello"); } );
 670                  * @before <p onblur="alert('Hello');">Hello</p>
 671                  * @result alert('Hello'); // Only executed for the first blur
 672                  *
 673                  * @name oneblur
 674                  * @type jQuery
 675                  * @param Function fn A function to bind to the blur event on each of the matched elements.
 676                  * @cat Events/UI
 677                  */
 678
 679                 /**
 680                  * Removes a bound blur event from each of the matched
 681                  * elements. You must pass the identical function that was used in the original
 682                  * bind method.
 683                  *
 684                  * @example $("p").unblur( myFunction );
 685                  * @before <p onblur="myFunction">Hello</p>
 686                  * @result <p>Hello</p>
 687                  *
 688                  * @name unblur
 689                  * @type jQuery
 690                  * @param Function fn A function to unbind from the blur event on each of the matched elements.
 691                  * @cat Events/UI
 692                  */
 693
 694                 /**
 695                  * Removes all bound blur events from each of the matched elements.
 696                  *
 697                  * @example $("p").unblur();
 698                  * @before <p onblur="alert('Hello');">Hello</p>
 699                  * @result <p>Hello</p>
 700                  *
 701                  * @name unblur
 702                  * @type jQuery
 703                  * @cat Events/UI
 704                  */
 705
 706                 /**
 707                  * Bind a function to the load event of each matched element.
 708                  *
 709                  * @example $("p").load( function() { alert("Hello"); } );
 710                  * @before <p>Hello</p>
 711                  * @result <p onload="alert('Hello');">Hello</p>
 712                  *
 713                  * @name load
 714                  * @type jQuery
 715                  * @param Function fn A function to bind to the load event on each of the matched elements.
 716                  * @cat Events/Browser
 717                  */
 718
 719                 /**
 720                  * Trigger the load event of each matched element. This causes all of the functions
 721                  * that have been bound to thet load event to be executed.
 722                  *
 723                  * @example $("p").load();
 724                  * @before <p onload="alert('Hello');">Hello</p>
 725                  * @result alert('Hello');
 726                  *
 727                  * @name load
 728                  * @type jQuery
 729                  * @cat Events/Browser
 730                  */
 731
 732                 /**
 733                  * Bind a function to the load event of each matched element, which will only be executed once.
 734                  * Unlike a call to the normal .load() method, calling .oneload() causes the bound function to be
 735                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 736                  *
 737                  * @example $("p").oneload( function() { alert("Hello"); } );
 738                  * @before <p onload="alert('Hello');">Hello</p>
 739                  * @result alert('Hello'); // Only executed for the first load
 740                  *
 741                  * @name oneload
 742                  * @type jQuery
 743                  * @param Function fn A function to bind to the load event on each of the matched elements.
 744                  * @cat Events/Browser
 745                  */
 746
 747                 /**
 748                  * Removes a bound load event from each of the matched
 749                  * elements. You must pass the identical function that was used in the original
 750                  * bind method.
 751                  *
 752                  * @example $("p").unload( myFunction );
 753                  * @before <p onload="myFunction">Hello</p>
 754                  * @result <p>Hello</p>
 755                  *
 756                  * @name unload
 757                  * @type jQuery
 758                  * @param Function fn A function to unbind from the load event on each of the matched elements.
 759                  * @cat Events/Browser
 760                  */
 761
 762                 /**
 763                  * Removes all bound load events from each of the matched elements.
 764                  *
 765                  * @example $("p").unload();
 766                  * @before <p onload="alert('Hello');">Hello</p>
 767                  * @result <p>Hello</p>
 768                  *
 769                  * @name unload
 770                  * @type jQuery
 771                  * @cat Events/Browser
 772                  */
 773
 774                 /**
 775                  * Bind a function to the select event of each matched element.
 776                  *
 777                  * @example $("p").select( function() { alert("Hello"); } );
 778                  * @before <p>Hello</p>
 779                  * @result <p onselect="alert('Hello');">Hello</p>
 780                  *
 781                  * @name select
 782                  * @type jQuery
 783                  * @param Function fn A function to bind to the select event on each of the matched elements.
 784                  * @cat Events/Form
 785                  */
 786
 787                 /**
 788                  * Trigger the select event of each matched element. This causes all of the functions
 789                  * that have been bound to thet select event to be executed.
 790                  *
 791                  * @example $("p").select();
 792                  * @before <p onselect="alert('Hello');">Hello</p>
 793                  * @result alert('Hello');
 794                  *
 795                  * @name select
 796                  * @type jQuery
 797                  * @cat Events/Form
 798                  */
 799
 800                 /**
 801                  * Bind a function to the select event of each matched element, which will only be executed once.
 802                  * Unlike a call to the normal .select() method, calling .oneselect() causes the bound function to be
 803                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 804                  *
 805                  * @example $("p").oneselect( function() { alert("Hello"); } );
 806                  * @before <p onselect="alert('Hello');">Hello</p>
 807                  * @result alert('Hello'); // Only executed for the first select
 808                  *
 809                  * @name oneselect
 810                  * @type jQuery
 811                  * @param Function fn A function to bind to the select event on each of the matched elements.
 812                  * @cat Events/Form
 813                  */
 814
 815                 /**
 816                  * Removes a bound select event from each of the matched
 817                  * elements. You must pass the identical function that was used in the original
 818                  * bind method.
 819                  *
 820                  * @example $("p").unselect( myFunction );
 821                  * @before <p onselect="myFunction">Hello</p>
 822                  * @result <p>Hello</p>
 823                  *
 824                  * @name unselect
 825                  * @type jQuery
 826                  * @param Function fn A function to unbind from the select event on each of the matched elements.
 827                  * @cat Events/Form
 828                  */
 829
 830                 /**
 831                  * Removes all bound select events from each of the matched elements.
 832                  *
 833                  * @example $("p").unselect();
 834                  * @before <p onselect="alert('Hello');">Hello</p>
 835                  * @result <p>Hello</p>
 836                  *
 837                  * @name unselect
 838                  * @type jQuery
 839                  * @cat Events/Form
 840                  */
 841
 842                 /**
 843                  * Bind a function to the mouseup event of each matched element.
 844                  *
 845                  * @example $("p").mouseup( function() { alert("Hello"); } );
 846                  * @before <p>Hello</p>
 847                  * @result <p onmouseup="alert('Hello');">Hello</p>
 848                  *
 849                  * @name mouseup
 850                  * @type jQuery
 851                  * @param Function fn A function to bind to the mouseup event on each of the matched elements.
 852                  * @cat Events/Mouse
 853                  */
 854
 855                 /**
 856                  * Trigger the mouseup event of each matched element. This causes all of the functions
 857                  * that have been bound to thet mouseup event to be executed.
 858                  *
 859                  * @example $("p").mouseup();
 860                  * @before <p onmouseup="alert('Hello');">Hello</p>
 861                  * @result alert('Hello');
 862                  *
 863                  * @name mouseup
 864                  * @type jQuery
 865                  * @cat Events/Mouse
 866                  */
 867
 868                 /**
 869                  * Bind a function to the mouseup event of each matched element, which will only be executed once.
 870                  * Unlike a call to the normal .mouseup() method, calling .onemouseup() causes the bound function to be
 871                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 872                  *
 873                  * @example $("p").onemouseup( function() { alert("Hello"); } );
 874                  * @before <p onmouseup="alert('Hello');">Hello</p>
 875                  * @result alert('Hello'); // Only executed for the first mouseup
 876                  *
 877                  * @name onemouseup
 878                  * @type jQuery
 879                  * @param Function fn A function to bind to the mouseup event on each of the matched elements.
 880                  * @cat Events/Mouse
 881                  */
 882
 883                 /**
 884                  * Removes a bound mouseup event from each of the matched
 885                  * elements. You must pass the identical function that was used in the original
 886                  * bind method.
 887                  *
 888                  * @example $("p").unmouseup( myFunction );
 889                  * @before <p onmouseup="myFunction">Hello</p>
 890                  * @result <p>Hello</p>
 891                  *
 892                  * @name unmouseup
 893                  * @type jQuery
 894                  * @param Function fn A function to unbind from the mouseup event on each of the matched elements.
 895                  * @cat Events/Mouse
 896                  */
 897
 898                 /**
 899                  * Removes all bound mouseup events from each of the matched elements.
 900                  *
 901                  * @example $("p").unmouseup();
 902                  * @before <p onmouseup="alert('Hello');">Hello</p>
 903                  * @result <p>Hello</p>
 904                  *
 905                  * @name unmouseup
 906                  * @type jQuery
 907                  * @cat Events/Mouse
 908                  */
 909
 910                 /**
 911                  * Bind a function to the unload event of each matched element.
 912                  *
 913                  * @example $("p").unload( function() { alert("Hello"); } );
 914                  * @before <p>Hello</p>
 915                  * @result <p onunload="alert('Hello');">Hello</p>
 916                  *
 917                  * @name unload
 918                  * @type jQuery
 919                  * @param Function fn A function to bind to the unload event on each of the matched elements.
 920                  * @cat Events/Browser
 921                  */
 922
 923                 /**
 924                  * Trigger the unload event of each matched element. This causes all of the functions
 925                  * that have been bound to thet unload event to be executed.
 926                  *
 927                  * @example $("p").unload();
 928                  * @before <p onunload="alert('Hello');">Hello</p>
 929                  * @result alert('Hello');
 930                  *
 931                  * @name unload
 932                  * @type jQuery
 933                  * @cat Events/Browser
 934                  */
 935
 936                 /**
 937                  * Bind a function to the unload event of each matched element, which will only be executed once.
 938                  * Unlike a call to the normal .unload() method, calling .oneunload() causes the bound function to be
 939                  * only executed the first time it is triggered, and never again (unless it is re-bound).
 940                  *
 941                  * @example $("p").oneunload( function() { alert("Hello"); } );
 942                  * @before <p onunload="alert('Hello');">Hello</p>
 943                  * @result alert('Hello'); // Only executed for the first unload
 944                  *
 945                  * @name oneunload
 946                  * @type jQuery
 947                  * @param Function fn A function to bind to the unload event on each of the matched elements.
 948                  * @cat Events/Browser
 949                  */
 950
 951                 /**
 952                  * Removes a bound unload event from each of the matched
 953                  * elements. You must pass the identical function that was used in the original
 954                  * bind method.
 955                  *
 956                  * @example $("p").ununload( myFunction );
 957                  * @before <p onunload="myFunction">Hello</p>
 958                  * @result <p>Hello</p>
 959                  *
 960                  * @name ununload
 961                  * @type jQuery
 962                  * @param Function fn A function to unbind from the unload event on each of the matched elements.
 963                  * @cat Events/Browser
 964                  */
 965
 966                 /**
 967                  * Removes all bound unload events from each of the matched elements.
 968                  *
 969                  * @example $("p").ununload();
 970                  * @before <p onunload="alert('Hello');">Hello</p>
 971                  * @result <p>Hello</p>
 972                  *
 973                  * @name ununload
 974                  * @type jQuery
 975                  * @cat Events/Browser
 976                  */
 977
 978                 /**
 979                  * Bind a function to the change event of each matched element.
 980                  *
 981                  * @example $("p").change( function() { alert("Hello"); } );
 982                  * @before <p>Hello</p>
 983                  * @result <p onchange="alert('Hello');">Hello</p>
 984                  *
 985                  * @name change
 986                  * @type jQuery
 987                  * @param Function fn A function to bind to the change event on each of the matched elements.
 988                  * @cat Events/Form
 989                  */
 990
 991                 /**
 992                  * Trigger the change event of each matched element. This causes all of the functions
 993                  * that have been bound to thet change event to be executed.
 994                  *
 995                  * @example $("p").change();
 996                  * @before <p onchange="alert('Hello');">Hello</p>
 997                  * @result alert('Hello');
 998                  *
 999                  * @name change
1000                  * @type jQuery
1001                  * @cat Events/Form
1002                  */
1003
1004                 /**
1005                  * Bind a function to the change event of each matched element, which will only be executed once.
1006                  * Unlike a call to the normal .change() method, calling .onechange() causes the bound function to be
1007                  * only executed the first time it is triggered, and never again (unless it is re-bound).
1008                  *
1009                  * @example $("p").onechange( function() { alert("Hello"); } );
1010                  * @before <p onchange="alert('Hello');">Hello</p>
1011                  * @result alert('Hello'); // Only executed for the first change
1012                  *
1013                  * @name onechange
1014                  * @type jQuery
1015                  * @param Function fn A function to bind to the change event on each of the matched elements.
1016                  * @cat Events/Form
1017                  */
1018
1019                 /**
1020                  * Removes a bound change event from each of the matched
1021                  * elements. You must pass the identical function that was used in the original
1022                  * bind method.
1023                  *
1024                  * @example $("p").unchange( myFunction );
1025                  * @before <p onchange="myFunction">Hello</p>
1026                  * @result <p>Hello</p>
1027                  *
1028                  * @name unchange
1029                  * @type jQuery
1030                  * @param Function fn A function to unbind from the change event on each of the matched elements.
1031                  * @cat Events/Form
1032                  */
1033
1034                 /**
1035                  * Removes all bound change events from each of the matched elements.
1036                  *
1037                  * @example $("p").unchange();
1038                  * @before <p onchange="alert('Hello');">Hello</p>
1039                  * @result <p>Hello</p>
1040                  *
1041                  * @name unchange
1042                  * @type jQuery
1043                  * @cat Events/Form
1044                  */
1045
1046                 /**
1047                  * Bind a function to the mouseout event of each matched element.
1048                  *
1049                  * @example $("p").mouseout( function() { alert("Hello"); } );
1050                  * @before <p>Hello</p>
1051                  * @result <p onmouseout="alert('Hello');">Hello</p>
1052                  *
1053                  * @name mouseout
1054                  * @type jQuery
1055                  * @param Function fn A function to bind to the mouseout event on each of the matched elements.
1056                  * @cat Events/Mouse
1057                  */
1058
1059                 /**
1060                  * Trigger the mouseout event of each matched element. This causes all of the functions
1061                  * that have been bound to thet mouseout event to be executed.
1062                  *
1063                  * @example $("p").mouseout();
1064                  * @before <p onmouseout="alert('Hello');">Hello</p>
1065                  * @result alert('Hello');
1066                  *
1067                  * @name mouseout
1068                  * @type jQuery
1069                  * @cat Events/Mouse
1070                  */
1071
1072                 /**
1073                  * Bind a function to the mouseout event of each matched element, which will only be executed once.
1074                  * Unlike a call to the normal .mouseout() method, calling .onemouseout() causes the bound function to be
1075                  * only executed the first time it is triggered, and never again (unless it is re-bound).
1076                  *
1077                  * @example $("p").onemouseout( function() { alert("Hello"); } );
1078                  * @before <p onmouseout="alert('Hello');">Hello</p>
1079                  * @result alert('Hello'); // Only executed for the first mouseout
1080                  *
1081                  * @name onemouseout
1082                  * @type jQuery
1083                  * @param Function fn A function to bind to the mouseout event on each of the matched elements.
1084                  * @cat Events/Mouse
1085                  */
1086
1087                 /**
1088                  * Removes a bound mouseout event from each of the matched
1089                  * elements. You must pass the identical function that was used in the original
1090                  * bind method.
1091                  *
1092                  * @example $("p").unmouseout( myFunction );
1093                  * @before <p onmouseout="myFunction">Hello</p>
1094                  * @result <p>Hello</p>
1095                  *
1096                  * @name unmouseout
1097                  * @type jQuery
1098                  * @param Function fn A function to unbind from the mouseout event on each of the matched elements.
1099                  * @cat Events/Mouse
1100                  */
1101
1102                 /**
1103                  * Removes all bound mouseout events from each of the matched elements.
1104                  *
1105                  * @example $("p").unmouseout();
1106                  * @before <p onmouseout="alert('Hello');">Hello</p>
1107                  * @result <p>Hello</p>
1108                  *
1109                  * @name unmouseout
1110                  * @type jQuery
1111                  * @cat Events/Mouse
1112                  */
1113
1114                 /**
1115                  * Bind a function to the keyup event of each matched element.
1116                  *
1117                  * @example $("p").keyup( function() { alert("Hello"); } );
1118                  * @before <p>Hello</p>
1119                  * @result <p onkeyup="alert('Hello');">Hello</p>
1120                  *
1121                  * @name keyup
1122                  * @type jQuery
1123                  * @param Function fn A function to bind to the keyup event on each of the matched elements.
1124                  * @cat Events/Keyboard
1125                  */
1126
1127                 /**
1128                  * Trigger the keyup event of each matched element. This causes all of the functions
1129                  * that have been bound to thet keyup event to be executed.
1130                  *
1131                  * @example $("p").keyup();
1132                  * @before <p onkeyup="alert('Hello');">Hello</p>
1133                  * @result alert('Hello');
1134                  *
1135                  * @name keyup
1136                  * @type jQuery
1137                  * @cat Events/Keyboard
1138                  */
1139
1140                 /**
1141                  * Bind a function to the keyup event of each matched element, which will only be executed once.
1142                  * Unlike a call to the normal .keyup() method, calling .onekeyup() causes the bound function to be
1143                  * only executed the first time it is triggered, and never again (unless it is re-bound).
1144                  *
1145                  * @example $("p").onekeyup( function() { alert("Hello"); } );
1146                  * @before <p onkeyup="alert('Hello');">Hello</p>
1147                  * @result alert('Hello'); // Only executed for the first keyup
1148                  *
1149                  * @name onekeyup
1150                  * @type jQuery
1151                  * @param Function fn A function to bind to the keyup event on each of the matched elements.
1152                  * @cat Events/Keyboard
1153                  */
1154
1155                 /**
1156                  * Removes a bound keyup event from each of the matched
1157                  * elements. You must pass the identical function that was used in the original
1158                  * bind method.
1159                  *
1160                  * @example $("p").unkeyup( myFunction );
1161                  * @before <p onkeyup="myFunction">Hello</p>
1162                  * @result <p>Hello</p>
1163                  *
1164                  * @name unkeyup
1165                  * @type jQuery
1166                  * @param Function fn A function to unbind from the keyup event on each of the matched elements.
1167                  * @cat Events/Keyboard
1168                  */
1169
1170                 /**
1171                  * Removes all bound keyup events from each of the matched elements.
1172                  *
1173                  * @example $("p").unkeyup();
1174                  * @before <p onkeyup="alert('Hello');">Hello</p>
1175                  * @result <p>Hello</p>
1176                  *
1177                  * @name unkeyup
1178                  * @type jQuery
1179                  * @cat Events/Keyboard
1180                  */
1181
1182                 /**
1183                  * Bind a function to the click event of each matched element.
1184                  *
1185                  * @example $("p").click( function() { alert("Hello"); } );
1186                  * @before <p>Hello</p>
1187                  * @result <p onclick="alert('Hello');">Hello</p>
1188                  *
1189                  * @name click
1190                  * @type jQuery
1191                  * @param Function fn A function to bind to the click event on each of the matched elements.
1192                  * @cat Events/Mouse
1193                  */
1194
1195                 /**
1196                  * Trigger the click event of each matched element. This causes all of the functions
1197                  * that have been bound to thet click event to be executed.
1198                  *
1199                  * @example $("p").click();
1200                  * @before <p onclick="alert('Hello');">Hello</p>
1201                  * @result alert('Hello');
1202                  *
1203                  * @name click
1204                  * @type jQuery
1205                  * @cat Events/Mouse
1206                  */
1207
1208                 /**
1209                  * Bind a function to the click event of each matched element, which will only be executed once.
1210                  * Unlike a call to the normal .click() method, calling .oneclick() causes the bound function to be
1211                  * only executed the first time it is triggered, and never again (unless it is re-bound).
1212                  *
1213                  * @example $("p").oneclick( function() { alert("Hello"); } );
1214                  * @before <p onclick="alert('Hello');">Hello</p>
1215                  * @result alert('Hello'); // Only executed for the first click
1216                  *
1217                  * @name oneclick
1218                  * @type jQuery
1219                  * @param Function fn A function to bind to the click event on each of the matched elements.
1220                  * @cat Events/Mouse
1221                  */
1222
1223                 /**
1224                  * Removes a bound click event from each of the matched
1225                  * elements. You must pass the identical function that was used in the original
1226                  * bind method.
1227                  *
1228                  * @example $("p").unclick( myFunction );
1229                  * @before <p onclick="myFunction">Hello</p>
1230                  * @result <p>Hello</p>
1231                  *
1232                  * @name unclick
1233                  * @type jQuery
1234                  * @param Function fn A function to unbind from the click event on each of the matched elements.
1235                  * @cat Events/Mouse
1236                  */
1237
1238                 /**
1239                  * Removes all bound click events from each of the matched elements.
1240                  *
1241                  * @example $("p").unclick();
1242                  * @before <p onclick="alert('Hello');">Hello</p>
1243                  * @result <p>Hello</p>
1244                  *
1245                  * @name unclick
1246                  * @type jQuery
1247                  * @cat Events/Mouse
1248                  */
1249
1250                 /**
1251                  * Bind a function to the resize event of each matched element.
1252                  *
1253                  * @example $("p").resize( function() { alert("Hello"); } );
1254                  * @before <p>Hello</p>
1255                  * @result <p onresize="alert('Hello');">Hello</p>
1256                  *
1257                  * @name resize
1258                  * @type jQuery
1259                  * @param Function fn A function to bind to the resize event on each of the matched elements.
1260                  * @cat Events/Browser
1261                  */
1262
1263                 /**
1264                  * Trigger the resize event of each matched element. This causes all of the functions
1265                  * that have been bound to thet resize event to be executed.
1266                  *
1267                  * @example $("p").resize();
1268                  * @before <p onresize="alert('Hello');">Hello</p>
1269                  * @result alert('Hello');
1270                  *
1271                  * @name resize
1272                  * @type jQuery
1273                  * @cat Events/Browser
1274                  */
1275
1276                 /**
1277                  * Bind a function to the resize event of each matched element, which will only be executed once.
1278                  * Unlike a call to the normal .resize() method, calling .oneresize() causes the bound function to be
1279                  * only executed the first time it is triggered, and never again (unless it is re-bound).
1280                  *
1281                  * @example $("p").oneresize( function() { alert("Hello"); } );
1282                  * @before <p onresize="alert('Hello');">Hello</p>
1283                  * @result alert('Hello'); // Only executed for the first resize
1284                  *
1285                  * @name oneresize
1286                  * @type jQuery
1287                  * @param Function fn A function to bind to the resize event on each of the matched elements.
1288                  * @cat Events/Browser
1289                  */
1290
1291                 /**
1292                  * Removes a bound resize event from each of the matched
1293                  * elements. You must pass the identical function that was used in the original
1294                  * bind method.
1295                  *
1296                  * @example $("p").unresize( myFunction );
1297                  * @before <p onresize="myFunction">Hello</p>
1298                  * @result <p>Hello</p>
1299                  *
1300                  * @name unresize
1301                  * @type jQuery
1302                  * @param Function fn A function to unbind from the resize event on each of the matched elements.
1303                  * @cat Events/Browser
1304                  */
1305
1306                 /**
1307                  * Removes all bound resize events from each of the matched elements.
1308                  *
1309                  * @example $("p").unresize();
1310                  * @before <p onresize="alert('Hello');">Hello</p>
1311                  * @result <p>Hello</p>
1312                  *
1313                  * @name unresize
1314                  * @type jQuery
1315                  * @cat Events/Browser
1316                  */
1317
1318                 /**
1319                  * Bind a function to the mousemove event of each matched element.
1320                  *
1321                  * @example $("p").mousemove( function() { alert("Hello"); } );
1322                  * @before <p>Hello</p>
1323                  * @result <p onmousemove="alert('Hello');">Hello</p>
1324                  *
1325                  * @name mousemove
1326                  * @type jQuery
1327                  * @param Function fn A function to bind to the mousemove event on each of the matched elements.
1328                  * @cat Events/Mouse
1329                  */
1330
1331                 /**
1332                  * Trigger the mousemove event of each matched element. This causes all of the functions
1333                  * that have been bound to thet mousemove event to be executed.
1334                  *
1335                  * @example $("p").mousemove();
1336                  * @before <p onmousemove="alert('Hello');">Hello</p>
1337                  * @result alert('Hello');
1338                  *
1339                  * @name mousemove
1340                  * @type jQuery
1341                  * @cat Events/Mouse
1342                  */
1343
1344                 /**
1345                  * Bind a function to the mousemove event of each matched element, which will only be executed once.
1346                  * Unlike a call to the normal .mousemove() method, calling .onemousemove() causes the bound function to be
1347                  * only executed the first time it is triggered, and never again (unless it is re-bound).
1348                  *
1349                  * @example $("p").onemousemove( function() { alert("Hello"); } );
1350                  * @before <p onmousemove="alert('Hello');">Hello</p>
1351                  * @result alert('Hello'); // Only executed for the first mousemove
1352                  *
1353                  * @name onemousemove
1354                  * @type jQuery
1355                  * @param Function fn A function to bind to the mousemove event on each of the matched elements.
1356                  * @cat Events/Mouse
1357                  */
1358
1359                 /**
1360                  * Removes a bound mousemove event from each of the matched
1361                  * elements. You must pass the identical function that was used in the original
1362                  * bind method.
1363                  *
1364                  * @example $("p").unmousemove( myFunction );
1365                  * @before <p onmousemove="myFunction">Hello</p>
1366                  * @result <p>Hello</p>
1367                  *
1368                  * @name unmousemove
1369                  * @type jQuery
1370                  * @param Function fn A function to unbind from the mousemove event on each of the matched elements.
1371                  * @cat Events/Mouse
1372                  */
1373
1374                 /**
1375                  * Removes all bound mousemove events from each of the matched elements.
1376                  *
1377                  * @example $("p").unmousemove();
1378                  * @before <p onmousemove="alert('Hello');">Hello</p>
1379                  * @result <p>Hello</p>
1380                  *
1381                  * @name unmousemove
1382                  * @type jQuery
1383                  * @cat Events/Mouse
1384                  */
1385
1386                 /**
1387                  * Bind a function to the mousedown event of each matched element.
1388                  *
1389                  * @example $("p").mousedown( function() { alert("Hello"); } );
1390                  * @before <p>Hello</p>
1391                  * @result <p onmousedown="alert('Hello');">Hello</p>
1392                  *
1393                  * @name mousedown
1394                  * @type jQuery
1395                  * @param Function fn A function to bind to the mousedown event on each of the matched elements.
1396                  * @cat Events/Mouse
1397                  */
1398
1399                 /**
1400                  * Trigger the mousedown event of each matched element. This causes all of the functions
1401                  * that have been bound to thet mousedown event to be executed.
1402                  *
1403                  * @example $("p").mousedown();
1404                  * @before <p onmousedown="alert('Hello');">Hello</p>
1405                  * @result alert('Hello');
1406                  *
1407                  * @name mousedown
1408                  * @type jQuery
1409                  * @cat Events/Mouse
1410                  */
1411
1412                 /**
1413                  * Bind a function to the mousedown event of each matched element, which will only be executed once.
1414                  * Unlike a call to the normal .mousedown() method, calling .onemousedown() causes the bound function to be
1415                  * only executed the first time it is triggered, and never again (unless it is re-bound).
1416                  *
1417                  * @example $("p").onemousedown( function() { alert("Hello"); } );
1418                  * @before <p onmousedown="alert('Hello');">Hello</p>
1419                  * @result alert('Hello'); // Only executed for the first mousedown
1420                  *
1421                  * @name onemousedown
1422                  * @type jQuery
1423                  * @param Function fn A function to bind to the mousedown event on each of the matched elements.
1424                  * @cat Events/Mouse
1425                  */
1426
1427                 /**
1428                  * Removes a bound mousedown event from each of the matched
1429                  * elements. You must pass the identical function that was used in the original
1430                  * bind method.
1431                  *
1432                  * @example $("p").unmousedown( myFunction );
1433                  * @before <p onmousedown="myFunction">Hello</p>
1434                  * @result <p>Hello</p>
1435                  *
1436                  * @name unmousedown
1437                  * @type jQuery
1438                  * @param Function fn A function to unbind from the mousedown event on each of the matched elements.
1439                  * @cat Events/Mouse
1440                  */
1441
1442                 /**
1443                  * Removes all bound mousedown events from each of the matched elements.
1444                  *
1445                  * @example $("p").unmousedown();
1446                  * @before <p onmousedown="alert('Hello');">Hello</p>
1447                  * @result <p>Hello</p>
1448                  *
1449                  * @name unmousedown
1450                  * @type jQuery
1451                  * @cat Events/Mouse
1452                  */
1453
1454                  /**
1455                   * @test var count;
1456                   * var e = ("blur,focus,load,resize,scroll,unload,click,dblclick," +
1457                   *             "mousedown,mouseup,mousemove,mouseover,mouseout,change,reset,select," +
1458                   *             "submit,keydown,keypress,keyup,error").split(",");
1459                   * var handler1 = function(event) {
1460                   *     count++;
1461                   * };
1462                   * var handler2 = function(event) {
1463                   *     count++;
1464                   * };
1465                   * for( var i=0; i < e.length; i++) {
1466                   *     var event = e[i];
1467                   *     count = 0;
1468                   *     // bind handler
1469                   *     $(document)[event](handler1);
1470                   *             $(document)[event](handler2);
1471                   *     $(document)["one"+event](handler1);
1472                   *
1473                   *     // call event two times
1474                   *     $(document)[event]();
1475                   *     $(document)[event]();
1476                   *
1477                   *     // unbind events
1478                   *     $(document)["un"+event](handler1);
1479                   *     // call once more
1480                   *     $(document)[event]();
1481                   *
1482                   *     // remove all handlers
1483                   *             $(document)["un"+event]();
1484                   *
1485                   *     // call once more
1486                   *     $(document)[event]();
1487                   *
1488                   *     // assert count
1489                   * @test ok( count == 6, 'Checking event ' + event);
1490                   * }
1491                   *
1492                   * @private
1493                   * @name eventTesting
1494                   */
1495
1496         var e = ("blur,focus,load,resize,scroll,unload,click,dblclick," +
1497                 "mousedown,mouseup,mousemove,mouseover,mouseout,change,reset,select," +
1498                 "submit,keydown,keypress,keyup,error").split(",");
1499
1500         // Go through all the event names, but make sure that
1501         // it is enclosed properly
1502         for ( var i = 0; i < e.length; i++ ) new function(){
1503
1504                 var o = e[i];
1505
1506                 // Handle event binding
1507                 jQuery.fn[o] = function(f){
1508                         return f ? this.bind(o, f) : this.trigger(o);
1509                 };
1510
1511                 // Handle event unbinding
1512                 jQuery.fn["un"+o] = function(f){ return this.unbind(o, f); };
1513
1514                 // Finally, handle events that only fire once
1515                 jQuery.fn["one"+o] = function(f){
1516                         // Attach the event listener
1517                         return this.each(function(){
1518
1519                                 var count = 0;
1520
1521                                 // Add the event
1522                                 jQuery.event.add( this, o, function(e){
1523                                         // If this function has already been executed, stop
1524                                         if ( count++ ) return;
1525
1526                                         // And execute the bound function
1527                                         return f.apply(this, [e]);
1528                                 });
1529                         });
1530                 };
1531
1532         };
1533
1534         // If Mozilla is used
1535         if ( jQuery.browser.mozilla || jQuery.browser.opera ) {
1536                 // Use the handy event callback
1537                 document.addEventListener( "DOMContentLoaded", jQuery.ready, false );
1538
1539         // If IE is used, use the excellent hack by Matthias Miller
1540         // http://www.outofhanwell.com/blog/index.php?title=the_window_onload_problem_revisited
1541         } else if ( jQuery.browser.msie ) {
1542
1543                 // Only works if you document.write() it
1544                 document.write("<scr" + "ipt id=__ie_init defer=true " +
1545                         "src=//:><\/script>");
1546
1547                 // Use the defer script hack
1548                 var script = document.getElementById("__ie_init");
1549                 script.onreadystatechange = function() {
1550                         if ( this.readyState != "complete" ) return;
1551                         this.parentNode.removeChild( this );
1552                         jQuery.ready();
1553                 };
1554
1555                 // Clear from memory
1556                 script = null;
1557
1558         // If Safari  is used
1559         } else if ( jQuery.browser.safari ) {
1560                 // Continually check to see if the document.readyState is valid
1561                 jQuery.safariTimer = setInterval(function(){
1562                         // loaded and complete are both valid states
1563                         if ( document.readyState == "loaded" ||
1564                                 document.readyState == "complete" ) {
1565
1566                                 // If either one are found, remove the timer
1567                                 clearInterval( jQuery.safariTimer );
1568                                 jQuery.safariTimer = null;
1569
1570                                 // and execute any waiting functions
1571                                 jQuery.ready();
1572                         }
1573                 }, 10);
1574         }
1575
1576         // A fallback to window.onload, that will always work
1577         jQuery.event.add( window, "load", jQuery.ready );
1578
1579 };