Modules (188)

AppInit

Description

Defines hooks to assist with module initialization.

This module defines 3 methods for client modules to attach callbacks:

htmlReady - When the main application template is rendered
extensionsLoaded - When the extension manager has loaded all extensions
appReady - When Brackets completes loading all modules and extensions

These are not jQuery events. Each method is similar to $(document).ready in that it will call the handler immediately if brackets is already done loading.

Dependencies

This module has no dependencies

Variables Show Private Members

Public API

APP_READY Constant

Fires when all extensions are loaded

Type: string

    var APP_READY   = "appReady";

Public API

EXTENSIONS_LOADED Constant

Fires after extensions have been loaded

Type: string

    var EXTENSIONS_LOADED = "extensionsLoaded";

Public API

HTML_READY Constant

Fires when the base htmlContent/main-view.html is loaded

Type: string

    var HTML_READY  = "htmlReady";

Private

_callbacks

Map of callbacks to states

Type: Object.<string, Array.<function()>>

    var _callbacks   = {};

    _callbacks[HTML_READY]        = [];
    _callbacks[APP_READY]         = [];
    _callbacks[EXTENSIONS_LOADED] = [];

Private

_status

Map of each state's trigger

Type: Object.<string, boolean>

    var _status      = { HTML_READY : false, APP_READY : false, EXTENSIONS_LOADED: false };

Functions Show Private Members

Private

_addListener

adds a callback to the list of functions to call for the specified event type

type string: the event type to dispatch (APP_READY, EXTENSIONS_READY, HTML_READY)
handler function: callback funciton to call when the event is triggered

    function _addListener(type, handler) {
        if (_status[type]) {
            _callHandler(handler);
        } else {
            _callbacks[type].push(handler);
        }
    }

Private

_callHandler

calls the specified handler inside a try/catch handler

handler function(): the callback to call

    function _callHandler(handler) {
        try {
            // TODO (issue 1034): We *could* use a $.Deferred for this, except deferred objects enter a broken
            // state if any resolution callback throws an exception. Since third parties (e.g. extensions) may
            // add callbacks to this, we need to be robust to exceptions
            handler();
        } catch (e) {
            console.error("Exception when calling a 'brackets done loading' handler: " + e);
            console.log(e.stack);
        }
    }

Private Public API

_dispatchReady

dispatches the event by calling all handlers registered for that type

type string: the event type to dispatch (APP_READY, EXTENSIONS_READY, HTML_READY)

    function _dispatchReady(type) {
        var i,
            myHandlers = _callbacks[type];

        // mark this status complete
        _status[type] = true;

        for (i = 0; i < myHandlers.length; i++) {
            _callHandler(myHandlers[i]);
        }

        // clear all callbacks after being called
        _callbacks[type] = [];
    }

Public API

appReady

Adds a callback for the ready hook. Handlers are called after htmlReady is done, the initial project is loaded, and all extensions are loaded.

handler function: callback function to call when the event is fired

    function appReady(handler) {
        _addListener(APP_READY, handler);
    }

Public API

extensionsLoaded

Adds a callback for the extensionsLoaded hook. Handlers are called after the extensions have been loaded

handler function: callback function to call when the event is fired

    function extensionsLoaded(handler) {
        _addListener(EXTENSIONS_LOADED, handler);
    }

    // Public API
    exports.appReady = appReady;
    exports.htmlReady = htmlReady;
    exports.extensionsLoaded = extensionsLoaded;

    exports.HTML_READY = HTML_READY;
    exports.APP_READY = APP_READY;
    exports.EXTENSIONS_LOADED = EXTENSIONS_LOADED;

    // Unit Test API
    exports._dispatchReady = _dispatchReady;
});

Public API

htmlReady

Adds a callback for the htmlReady hook. Handlers are called after the main application html template is rendered.

handler function: callback function to call when the event is fired

    function htmlReady(handler) {
        _addListener(HTML_READY, handler);
    }