Show: Inherited Protected Private Deprecated

# File `src/core/debounce.js`

                                (function() {
                                    'use strict';

                                    /**
                                     * CKEDITOR.tools class utility which adds additional methods to those of CKEditor.
                                     *
                                     * @class CKEDITOR.tools
                                     */

                                    /**
                                     * Debounce util function. If a function execution is expensive, it might be debounced. This means
                                     * that it will be executed after some amount of time after its last call. For example, if we attach a
                                     * a function on scroll event, it might be called hundreds times per second. In this case it may be
                                     * debounced with, let's say 100ms. The real execution of this function will happen 100ms after last
                                     * scroll event.
                                     *
                                     * @static
                                     * @method debounce
                                     * @param {Function} callback The callback which has to be called after given timeout.
                                     * @param {Number} timeout Timeout in milliseconds after which the callback will be called.
                                     * @param {Object} context The context in which the callback will be called. This argument is optional.
                                     * @param {Array} args An array of arguments which the callback will receive.
                                     */
                                    CKEDITOR.tools.debounce = CKEDITOR.tools.debounce || function(callback, timeout, context, args) {
                                        var debounceHandle;

                                        var callFn = function() {
                                            var callContext = context || this;

                                            clearTimeout(debounceHandle);

                                            var result = [];

                                            for (var len = arguments.length, startIndex = 0; startIndex < len; ++startIndex) {
                                                result.push(arguments[startIndex]);
                                            }

                                            var callArgs = result.concat(args || []);

                                            debounceHandle = setTimeout(function() {
                                                callback.apply(callContext, callArgs);
                                            }, timeout);
                                        };

                                        callFn.detach = function() {
                                            clearTimeout(debounceHandle);
                                        };

                                        return callFn;
                                    };
                                }());