Changeset 4683


Ignore:
Timestamp:
12/12/09 13:51:00 (6 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 – 2015 CKSource – Frederico Knabben. All rights reserved. | Terms of use | Privacy policy