Changeset 4683


Ignore:
Timestamp:
12/12/09 13:51:00 (4 years ago)
Author:
fredck
Message:

Added documentation to some CKEDITOR.tools functions.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • CKEditor/trunk/_source/core/tools.js

    r4682 r4683  
    2020        CKEDITOR.tools = 
    2121        { 
     22                /** 
     23                 * Compare the elements of two arrays. 
     24                 * @param {Array} arrayA An array to be compared. 
     25                 * @param {Array} arrayB The other array to be compared. 
     26                 * @returns {Boolean} "true" is the arrays have the same lenght and 
     27                 *              their elements match. 
     28                 * @example 
     29                 * var a = [ 1, 'a', 3 ]; 
     30                 * var b = [ 1, 3, 'a' ]; 
     31                 * var c = [ 1, 'a', 3 ]; 
     32                 * var d = [ 1, 'a', 3, 4 ]; 
     33                 * 
     34                 * alert( CKEDITOR.tools.arrayCompare( a, b ) );  // false 
     35                 * alert( CKEDITOR.tools.arrayCompare( a, c ) );  // true 
     36                 * alert( CKEDITOR.tools.arrayCompare( a, d ) );  // false 
     37                 */ 
    2238                arrayCompare : function( arrayA, arrayB ) 
    2339                { 
     
    462478                                }, 
    463479 
     480                /** 
     481                 * Creates a function that will always execute in the context of a 
     482                 * specified object. 
     483                 * @param {Function} func The function to be executed. 
     484                 * @param {Object} obj The object to which bind the execution context. 
     485                 * @returns {Function} The function that can be used to execute the 
     486                 *              "func" function in the context of "obj". 
     487                 * @example 
     488                 * var obj = { text : 'My Object' }; 
     489                 * 
     490                 * function alertText() 
     491                 * { 
     492                 *     alert( this.text ); 
     493                 * } 
     494                 * 
     495                 * var newFunc = <b>CKEDITOR.tools.bind( alertText, obj )</b>; 
     496                 * newFunc();  // Alerts "My Object". 
     497                 */ 
    464498                bind : function( func, obj ) 
    465499                { 
     
    473507                 * <li> Static fields </li> 
    474508                 * <li> Private fields </li> 
    475                  * <li> Public(prototype) fields </li> 
     509                 * <li> Public (prototype) fields </li> 
    476510                 * <li> Chainable base class constructor </li> 
    477511                 * </ul> 
    478                  * 
    479                  * @param {Object} definiton (Optional)The class definiton object. 
     512                 * @param {Object} definiton The class definiton object. 
     513                 * @returns {Function} A class-like JavaScript function. 
    480514                 */ 
    481515                createClass : function( definition ) 
     
    530564                }, 
    531565 
     566                /** 
     567                 * Creates a function reference that can be called later using 
     568                 * CKEDITOR.tools.callFunction. This approach is specially useful to 
     569                 * make DOM attribute function calls to JavaScript defined functions. 
     570                 * @param {Function} fn The function to be executed on call. 
     571                 * @param {Object} [scope] The object to have the context on "fn" execution. 
     572                 * @returns {Number} A unique reference to be used in conjuction with 
     573                 *              CKEDITOR.tools.callFunction. 
     574                 * @example 
     575                 * var ref = <b>CKEDITOR.tools.addFunction</b>( 
     576                 *     function() 
     577                 *     { 
     578                 *         alert( 'Hello!'); 
     579                 *     }); 
     580                 * CKEDITOR.tools.callFunction( ref );  // Hello! 
     581                 */ 
    532582                addFunction : function( fn, scope ) 
    533583                { 
     
    538588                }, 
    539589 
    540                 callFunction : function( index ) 
    541                 { 
    542                         var fn = functions[ index ]; 
    543                         return fn.apply( window, Array.prototype.slice.call( arguments, 1 ) ); 
     590                /** 
     591                 * Executes a function based on the reference created with 
     592                 * CKEDITOR.tools.addFunction. 
     593                 * @param {Number} ref The function reference created with 
     594                 *              CKEDITOR.tools.addFunction. 
     595                 * @param {[Any,[Any,...]} params Any number of parameters to be passed 
     596                 *              to the executed function. 
     597                 * @returns {Any} The return value of the function. 
     598                 * @example 
     599                 * var ref = CKEDITOR.tools.addFunction( 
     600                 *     function() 
     601                 *     { 
     602                 *         alert( 'Hello!'); 
     603                 *     }); 
     604                 * <b>CKEDITOR.tools.callFunction( ref )</b>;  // Hello! 
     605                 */ 
     606                callFunction : function( ref ) 
     607                { 
     608                        var fn = functions[ ref ]; 
     609                        return fn && fn.apply( window, Array.prototype.slice.call( arguments, 1 ) ); 
    544610                }, 
    545611 
Note: See TracChangeset for help on using the changeset viewer.
© 2003 – 2012 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy