Modules (181)

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

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

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);
    }