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()>>
Private
    var _callbacks   = {};

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

_status

Map of each state's trigger

Type
Object.<string, boolean>
Private
    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);
    }