value: function(type, canBubble, cancelable, detail) {
var event = MutableEvent.fromType(type, canBubble, cancelable, detail);
event.target = this;
defaultEventManager.handleEvent(event);
return !event.defaultPrevented;
}
value: function(event) {
var targettedEvent = event;
if (! (event instanceof MutableEvent)) {
targettedEvent = MutableEvent.fromEvent(targettedEvent);
}
targettedEvent.target = this;
defaultEventManager.handleEvent(targettedEvent);
return !event.defaultPrevented;
}
value: function() {
var self = this,
insertionElement;
if (logger.isDebug) {
logger.debug(this, "main preparing to draw");
}
this.isLoadingMainComponent = false;
// Determine old content
this._contentToRemove = document.createRange();
// If installing classnames on the documentElement (to affect as high a level as possible)
// make sure content only ends up inside the body
insertionElement = this.element === document.documentElement ? document.body : this.element;
this._contentToRemove.selectNodeContents(insertionElement);
// Add new content so mainComponent can actually draw
this.childComponents = [this._mainComponent];
insertionElement.appendChild(this._mainComponent.element);
var startBootstrappingTimeout = document[bootstrappingTimeoutPropertyName],
timing = document._montageTiming,
remainingBootstrappingDelay,
remainingLoadingDelay;
// if we hadn't even started to say we were bootstrapping…
if (!timing.bootstrappingStartTime) {
// don't bother showing bootstrapping, just show the mainComponent
if (logger.isDebug) {
logger.debug(this, "bootstrapper never shown");
}
clearTimeout(startBootstrappingTimeout);
startBootstrappingTimeout = null;
this._revealMainComponent();
}
// Otherwise if we started bootstrapping, but never started loading…
else if (timing.bootstrappingStartTime && !timing.loadingStartTime) {
// don't ever show the loader and wait until we've bootstrapped for the minimumBootstrappingDuration
clearTimeout(this._showLoadingTimeout);
this._showLoadingTimeout = null;
timing.bootstrappingEndTime = Date.now();
if ((remainingBootstrappingDelay = this.minimumBootstrappingDuration - (timing.bootstrappingEndTime - timing.bootstrappingStartTime)) > 0) {
if (logger.isDebug) {
logger.debug(this, "show bootstrapper for another " + remainingBootstrappingDelay + "ms");
}
this._showMainComponentTimeout = setTimeout(function () {
if (logger.isDebug) {
logger.debug(this, "ok, shown bootstrapper long enough");
}
self._revealMainComponent();
}, remainingBootstrappingDelay);
} else {
setTimeout(function () {
if (logger.isDebug) {
logger.debug(this, "ok, showing bootstrapper now");
}
self._revealMainComponent();
}, 0);
}
}
//Otherwise, we apparently started showing loading progress…
else if (timing.loadingStartTime) {
timing.loadingEndTime = Date.now();
// wait until we've loaded for the minimumLoadingDuration
// TODO this is not precise, but it's a decent start for scheduling the delay
if ((remainingLoadingDelay = this.minimumLoadingDuration - (timing.loadingEndTime - timing.loadingStartTime)) > 0) {
if (logger.isDebug) {
logger.debug(this, "show loader for another " + remainingLoadingDelay + "ms");
}
this._showMainComponentTimeout = setTimeout(function () {
if (logger.isDebug) {
logger.debug(this, "ok, shown loader long enough");
}
self._revealMainComponent();
}, remainingLoadingDelay);
} else {
// or we showed loading long enough, go ahead and show mainComponent
this._revealMainComponent();
}
}
var mainComponent = this._mainComponent;
// Remove the connection from the Loader to the DOM tree and add
// the main component to the component tree.
defaultEventManager.unregisterEventHandlerForElement(this.element);
mainComponent.attachToParentComponent();
// When the main component enters the document it is loaded, update
// the currentStage to reflect that situation if we're behind.
if (this.currentStage < LOADED) {
this.currentStage = LOADED;
}
mainComponent.enterDocument = this._mainComponentEnterDocument;
if (mainComponent.enterDocument) {
return mainComponent.enterDocument.apply(mainComponent, arguments);
}
}
value: function removeEventListener(type, listener, useCapture) {
if (listener) {
defaultEventManager.unregisterEventListener(this, type, listener, useCapture);
}
}