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