/*
This file contains proprietary software owned by Motorola Mobility, Inc. */
/**
@module montage/ui/component
@requires montage/core/core
@requires montage/ui/reel
@requires montage/core/gate
@requires montage/core/logger | component
@requires montage/core/logger | drawing
@requires montage/core/event/event-manager
*/
var Montage = require("montage").Montage,
Template = require("ui/template").Template,
Gate = require("core/gate").Gate,
logger = require("core/logger").logger("component"),
drawLogger = require("core/logger").logger("drawing"),
defaultEventManager = require("core/event/event-manager").defaultEventManager;
/**
* @class module:montage/ui/component.Component
* @classdesc Base class for all Montage components.
@extends module:montage/core/core.Montage
*/
var Component = exports.Component = Montage.create(Montage,/** @lends module:montage/ui/component.Component# */ {
/**
Description TODO
@type {Property}
@default null
*/
delegate: {
serializable: "reference",
value: null
},
parentProperty: {
serializable: true,
value: "parentComponent"
},
/**
Dispatch the actionEvent this component is configured to emit upon interaction
@private
*/
_dispatchActionEvent: {
value: function() {
this.dispatchEvent(this.createActionEvent());
},
enumerable: false
},
/**
Create a custom event to dispatch upon interaction
@type {Function}
@returns and event to dispatch upon interaction
*/
createActionEvent: {
value: function() {
var actionEvent = document.createEvent("CustomEvent");
actionEvent.initCustomEvent("action", true, true, null);
return actionEvent;
}
},
/**
Description TODO
@function
@returns this._canDrawGate
*/
canDrawGate: {
get: function() {
if (!this._canDrawGate) {
this._canDrawGate = Gate.create().initWithDelegate(this);
this._canDrawGate.setField("componentTreeLoaded", false);
}
return this._canDrawGate;
}
},
/**
Description TODO
@private
*/
_blockDrawGate: {
value: null
},
/**
Description TODO
@function
@returns this._blockDrawGate
*/
blockDrawGate: {
get: function() {
if (!this._blockDrawGate) {
this._blockDrawGate = Gate.create().initWithDelegate(this);
this._blockDrawGate.setField("element", false);
this._blockDrawGate.setField("drawRequested", false);
}
return this._blockDrawGate;
}
},
/**
Description TODO
@private
*/ _firstDraw: {
enumerable: false,
value: true
},
/**
Description TODO
@private
*/
_completedFirstDraw: {
enumerable: false,
value: false
},
/**
Description TODO
@private
*/
_element: {
enumerable: false,
value: null
},
/**
Description TODO
@type {Function}
@default null
*/
element: {
serializable: true,
enumerable: true,
get: function() {
return this._element;
},
set: function(value) {
if (value == null) {
console.warn("Tried to set element of ", this, " to ", value);
return;
}
if (this.isDeserializing) {
this.eventManager.registerEventHandlerForElement(this, value);
// if this component has a template and has been already instantiated then assume the value is the template.
if (this._isTemplateInstantiated) {
// this is important for component extension, we don't want to override template element
if (!this._templateElement) {
this._templateElement = value;
}
} else {
this._element = value;
if (!this.blockDrawGate.value && this._element) {
this.blockDrawGate.setField("element", true);
}
}
} else if (!this._firstDraw) {
// If a draw has happened then at some point the element has been set
console.error("Cannot change element of ", this, " after it has been set");
return;
} else {
this.eventManager.registerEventHandlerForElement(this, value);
this._element = value;
if (!this.blockDrawGate.value && this._element) {
this.blockDrawGate.setField("element", true);
}
}
}
},
setElementWithParentComponent: {
value: function(element, parent) {
this._alternateParentComponent = parent;
if (this.element != element) {
this.element = element;
}
}
},
// access to the Application object
/**
Description TODO
@function
@returns document.application
*/
application: {
get: function() {
return document.application;
}
},
/**
Description TODO
@function
@returns defaultEventManager
*/
eventManager: {
get: function() {
return defaultEventManager;
}
},
/**
Description TODO
@function
@returns rootComponent
*/
rootComponent: {
get: function() {
return rootComponent;
}
},
/**
Description TODO
@function
@returns {Boolean} false
*/
acceptsDirectFocus: {
enumerable: false,
value: function() {
return false;
}
},
/**
Description TODO
@function
@returns targetElementController
*/
elementControllerFromEvent: {
enumerable: false,
value: function(event, targetElementController) {
return targetElementController;
}
},
_alternateParentComponent: {
value: null
},
/**
Description TODO
@private
*/
_cachedParentComponent: {
value: null
},
// TODO store the value and delete it after draw
/**
The parent component is found by walking up the DOM tree from the node returned by the element property.]
// \s*(>)?\s* operator [>] (if undefined it's a space)
// @([^>\s]+) rightHandOperand []
// (.*) rest
var matches = selector.match(/^\s*(?:@([^>\s]+))?(?:\s*(>)?\s*@([^>\s]+)(.*))?$/);
if (!matches) {
throw "querySelectorComponent: Syntax error \"" + selector + "\"";
}
var childComponents = this.childComponents,
leftHandOperand = matches[1],
operator = matches[2] || " ",
rightHandOperand = matches[3],
rest = matches[4],
found;
if (leftHandOperand) {
rest = rightHandOperand ? "@"+rightHandOperand + rest : "";
for (var i = 0, childComponent; (childComponent = childComponents[i]); i++) {
if (leftHandOperand === Montage.getInfoForObject(childComponent).label) {
if (rest) {
return childComponent.querySelectorComponent(rest);
} else {
return childComponent;
}
} else {
found = childComponent.querySelectorComponent(selector);
if (found) {
return found;
}
}
}
} else {
for (var i = 0, childComponent; (childComponent = childComponents[i]); i++) {
if (rightHandOperand === Montage.getInfoForObject(childComponent).label) {
if (rest) {
return childComponent.querySelectorComponent(rest);
} else {
return childComponent;
}
}
}
}
return null;
}
},
querySelectorAllComponent: {
value: function(selector) {
if (typeof selector !== "string") {
throw "querySelectorComponent: Selector needs to be a string.";
}
// (@([^>\s]+)? leftHandOperand []
// \s*(>)?\s* operator [>] (if undefined it's a space)
// @([^>\s]+) rightHandOperand []
// (.*) rest
var matches = selector.match(/^\s*(?:@([^>\s]+))?(?:\s*(>)?\s*@([^>\s]+)(.*))?$/);
if (!matches) {
throw "querySelectorComponent: Syntax error \"" + selector + "\"";
}
var childComponents = this.childComponents,
leftHandOperand = matches[1],
operator = matches[2] || " ",
rightHandOperand = matches[3],
rest = matches[4],
found = [];
if (leftHandOperand) {
rest = rightHandOperand ? "@"+rightHandOperand + rest : "";
for (var i = 0, childComponent; (childComponent = childComponents[i]); i++) {
if (leftHandOperand === Montage.getInfoForObject(childComponent).label) {
if (rest) {
found = found.concat(childComponent.querySelectorAllComponent(rest));
} else {
found.push(childComponent);
}
} else {
found = found.concat(childComponent.querySelectorAllComponent(selector));
}
}
} else {
for (var i = 0, childComponent; (childComponent = childComponents[i]); i++) {
if (rightHandOperand === Montage.getInfoForObject(childComponent).label) {
if (rest) {
found = found.concat(childComponent.querySelectorAllComponent(rest));
} else {
found.push(childComponent);
}
}
}
}
return found;
}
},
/**
Description TODO
@type {Property}
@default null
*/
template: {
value: null
},
/**
Specifies whether the component has an HTML template file associated with it.
@type {Property}
@default {Boolean} true
*/
hasTemplate: {
value: true
},
/**
Description TODO
@type {Property}
@default null
*/
templateModuleId: {
value: null
},
_template: {
value: null
},
// Tree level necessary for ordering drawing re: parent-child
_treeLevel: {
value: 0
},
/**
Description TODO
@function
@param {Component} childComponent The childComponent
*/
_addChildComponent: {
value: function(childComponent) {
if (this.childComponents.indexOf(childComponent) == -1) {
this.childComponents.push(childComponent);
childComponent._cachedParentComponent = this;
}
}
},
/**
Description TODO
@function
*/
attachToParentComponent: {
value: function() {
this._cachedParentComponent = null;
var parentComponent = this.parentComponent,
childComponents,
childComponent;
if (parentComponent) {
childComponents = parentComponent.childComponents;
for (var i = 0; (childComponent = childComponents[i]); i++) {
var newParentComponent = childComponent.findParentComponent();
if (newParentComponent === this) {
parentComponent.removeChildComponent(childComponent);
newParentComponent._addChildComponent(childComponent);
}
}
parentComponent._addChildComponent(this);
}
}
},
detachFromParentComponent: {
value: function() {
var parentComponent = this.parentComponent;
if (parentComponent) {
parentComponent.removeChildComponent(this);
}
}
},
/**
Description TODO
@function
@param {Component} childComponent The childComponent
*/
removeChildComponent: {
value: function(childComponent) {
var childComponents = this.childComponents,
element = childComponent._element,
ix = childComponents.indexOf(childComponent);
if (ix > -1) {
childComponents.splice(ix, 1);
childComponent._cachedParentComponent = null;
childComponent._alternateParentComponent = null;
}
}
},
/**
Description TODO
@type {Property}
@default {Array} []
*/
childComponents: {
enumerable: false,
distinct: true,
value: []
},
/**
Description TODO
@type {Property}
@default null
*/
ownerComponent: {
enumerable: false,
value: null
},
/**
Description TODO
@type {Property}
@default {}
*/
components: {
enumerable: false,
value: {}
},
/**
Description TODO
@private
*/
_isComponentExpanded: {
enumerable: false,
value: null
},
_isTemplateLoaded: {
enumerable: false,
value: null
},
_isTemplateInstantiated: {
enumerable: false,
value: null
},
/**
* Remove all bindings and starts buffering the needsDraw.
* @function
*/
cleanupDeletedComponentTree: {
value: function(deleteBindings) {
// Deleting bindings in all cases was causing the symptoms expressed in gh-603
// Until we have a more granular way we shouldn't do this,
// the deleteBindings parameter is a short term fix.
if (deleteBindings) {
Object.deleteBindings(this);
}
this.needsDraw = false;
this.traverseComponentTree(function(component) {
// See above comment
if (deleteBindings) {
Object.deleteBindings(component);
}
component.needsDraw = false;
});
}
},
originalContent: {
value: null
},
_newDomContent: {
enumerable: false,
value: null
},
domContent: {
get: function() {
if (this._element) {
return Array.prototype.slice.call(this._element.childNodes, 0);
} else {
return null;
}
},
set: function(value) {
var components,
componentsToAdd = [];
this._newDomContent = value;
this.needsDraw = true;
if (this._newDomContent === null) {
this._shouldClearDomContentOnNextDraw = true;
}
if (typeof this.contentWillChange === "function") {
this.contentWillChange(value);
}
// cleanup current content
components = this.childComponents;
for (var i = 0, component; (component = components[i]); i++) {
component.detachFromParentComponent();
component.cleanupDeletedComponentTree();
}
if (value instanceof Element) {
findAndDetachComponents(value);
} else if (value) {
for (var i = 0; i < value.length; i++) {
findAndDetachComponents(value[i]);
}
}
// find the component fringe and detach them from the component tree
function findAndDetachComponents(node) {
var component = node.controller;
if (component) {
component.detachFromParentComponent();
componentsToAdd.push(component);
} else {
var childNodes = node.childNodes;
for (var i = 0, childNode; (childNode = childNodes[i]); i++) {
findAndDetachComponents(childNode);
}
}
}
// not sure if I can rely on _cachedParentComponent to detach the nodes instead of doing one loop for dettach and another to attach...
for (var i = 0, component; (component = componentsToAdd[i]); i++) {
this._addChildComponent(component);
}
}
},
_shouldClearDomContentOnNextDraw: {
value: false
},
/**
Description TODO
@function
*/
deserializedFromSerialization: {
value: function() {
this.attachToParentComponent();
if (this._element) {
this.originalContent = Array.prototype.slice.call(this._element.childNodes, 0);
}
if (! this.hasOwnProperty("identifier")) {
this.identifier = Montage.getInfoForObject(this).label;
}
}
},
serializeProperties: {
value: function(serializer) {
serializer.setAll();
var childComponents = this.childComponents;
for (var i = 0, l = childComponents.length; i < l; i++) {
serializer.addObject(childComponents[i]);
}
}
},
/**
This method is called right before draw is called.canDraw() returns false, then the component is re-added to the parent's draw list and draw isn't called.
@function
@returns {Boolean} true or false
*/
canDraw: {
value: function() {
return this._canDraw;
}
},
/**
Description TODO
@private
*/
_canDraw: {
get: function() {
return (!this._canDrawGate || this._canDrawGate.value);
},
set: function(value) {
rootComponent.componentCanDraw(this, value);
},
enumerable: false
},
/**
Description TODO
@private
*/
_prepareCanDraw: {
enumerable: false,
value: function _prepareCanDraw() {
if (!this._isComponentTreeLoaded) {
this.loadComponentTree();
}
}
},
/**
Description TODO
@private
*/
_loadComponentTreeCallbacks: {
enumerable: false,
value: null
},
/**
Description TODO
@private
*/
_isComponentTreeLoaded: {
enumerable: false,
value: null
},
/**
Description TODO
@private
*/
_isComponentTreeLoading: {
enumerable: false,
value: null
},
/**
Description TODO
@function
@param {Object} callback Callback object
@returns itself
*/
loadComponentTree: {value: function loadComponentTree(callback) {
var self = this,
canDrawGate = this.canDrawGate;
if (this._isComponentTreeLoaded) {
if (callback) {
callback(this);
}
return;
}
if (callback) {
if (this._loadComponentTreeCallbacks == null) {
this._loadComponentTreeCallbacks = [callback];
} else {
this._loadComponentTreeCallbacks.push(callback);
}
}
if (this._isComponentTreeLoading) {
return;
}
canDrawGate.setField("componentTreeLoaded", false);
// only put it in the root component's draw list if the component has requested to be draw, it's possible to load the component tree without asking for a draw.
// What about the hasTemplate check?
if (this.needsDraw || this.hasTemplate) {
this._canDraw = false;
}
function callCallbacks() {
var callback, callbacks = self._loadComponentTreeCallbacks;
self._isComponentTreeLoading = false;
self._isComponentTreeLoaded = true;
canDrawGate.setField("componentTreeLoaded", true);
if (callbacks) {
for (var i = 0; (callback = callbacks[i]); i++) {
callback(self);
}
self._loadComponentTreeCallbacks = callbacks = null;
}
}
this._isComponentTreeLoading = true;
this.expandComponent(function() {
var childComponent,
childComponents = self.childComponents,
childComponentsCount = childComponents.length,
childrenLoadedCount = 0,
i;
if (childComponentsCount === 0) {
callCallbacks();
return;
}
for (i = 0; (childComponent = childComponents[i]); i++) {
childComponent.loadComponentTree(function() {
if (++childrenLoadedCount === childComponentsCount) {
callCallbacks();
}
});
}
});
}},
/**
Description TODO
@function
@param {Property} visitor visitor
@param {Object} callback callback object
@returns itself
*/
traverseComponentTree: {value: function traverseComponentTree(visitor, callback) {
var self = this;
function traverse() {
var childComponents = self.childComponents;
var childComponent;
var childLeftCount;
if (visitor) {
// if the visitor returns false stop the traversal for this subtree
if (visitor(self) === false) {
if (callback) {
callback();
}
return;
}
}
if ((childLeftCount = childComponents.length) === 0) {
if (callback) {
callback();
}
return;
}
for (var i = 0; (childComponent = childComponents[i]); i++) {
childComponent.traverseComponentTree(visitor, function() {
if (--childLeftCount === 0 && callback) {
callback();
}
});
}
}
if (this._isComponentExpanded) {
traverse();
} else {
this.expandComponent(function() {
traverse();
});
}
}},
/**
Description TODO
@function
@param {Object} callback TODO
*/
expandComponent: {value: function expandComponent(callback) {
var self = this;
if (this.hasTemplate && !this._isTemplateInstantiated) {
this.loadTemplate(function() {
self._isComponentExpanded = true;
if (callback) {
callback();
}
});
} else {
self._isComponentExpanded = true;
if (callback) {
callback();
}
}
}},
/**
Description TODO
@private
*/
_loadTemplateCallbacks: {
enumerable: false,
value: null
},
/**
Description TODO
@function
@param {Object} callback TODO
*/
loadTemplate: {value: function loadTemplate(callback) {
var self = this;
if (!this._isTemplateInstantiated) {
this._loadTemplate(function(template) {
// this actually also serves as isTemplateInstantiating
self._isTemplateInstantiated = true;
template.instantiateWithComponent(self, function() {
if (callback) {
callback();
}
});
});
}
}},
_loadTemplate: {value: function _loadTemplate(callback) {
if (this._isTemplateLoaded) {
if (callback) {
callback(this._template);
}
return;
}
// TODO we can create _loadTemplateCallbacks with [] and use "distinct" after merging with master
if (callback) {
if (this._loadTemplateCallbacks === null) {
this._loadTemplateCallbacks = [callback];
} else {
this._loadTemplateCallbacks.push(callback);
}
}
if (this._isTemplateLoading) {
return;
}
this._isTemplateLoading = true;
var self = this;
var templateModuleId, info, moduleId;
var onTemplateLoad = function(template) {
var callbacks = self._loadTemplateCallbacks;
self._template = template;
self._isTemplateLoaded = true;
self._isTemplateLoading = false;
if (callbacks) {
for (var i = 0; (callback = callbacks[i]); i++) {
callback(template);
}
self._loadTemplateCallbacks = callbacks = null;
}
};
templateModuleId = this.templateModuleId;
info = Montage.getInfoForObject(this);
if (!templateModuleId) {
moduleId = info.moduleId;
// TODO: backwards compatibility for components with its controller outside the reel folder
//if (/([^\/]+)\.reel\/\1$/.exec(moduleId)) {
// templateModuleId = moduleId + ".html";
//} else if (/([^\/]+)\.reel$/.exec(moduleId)) {
// templateModuleId = moduleId + "/" + RegExp.$1 + ".html";
//} else {
var slashIndex = moduleId.lastIndexOf("/");
//templateModuleId = moduleId + ".reel/" + moduleId.split("/").pop() + ".html";
templateModuleId = moduleId + "/" + moduleId.slice(slashIndex === -1 ? 0 : slashIndex+1, -5) + ".html";
//}
}
if (logger.isDebug) {
logger.debug(this, "Will load " + templateModuleId);
}
// this call will be synchronous if the template is cached.
Template.templateWithModuleId(info.require, templateModuleId, onTemplateLoad);
}},
templateDidDeserializeObject: {
value: function(object) {
if (Component.isPrototypeOf(object)) {
object.ownerComponent = this;
}
}
},
/**
Callback for the _canDrawGate.canDraw()._drawIfNeeded() is called, otherwise they are ignored.
@private
*/
_drawIfNeeded: {
enumerable: false,
value: function _drawIfNeeded(level) {
var childComponent,
oldDrawList, i, childComponentListLength;
this._treeLevel = level;
if (this.needsDraw && !this._addedToDrawCycle) {
rootComponent.addToDrawCycle(this);
}
if (drawLogger.isDebug) {
drawLogger.debug(this, "drawList: " + (this._drawList || []).length + " of " + this.childComponents.length);
}
if (this._drawList !== null && this._drawList.length > 0) {
oldDrawList = this._drawList;
this._drawList = [];
childComponentListLength = oldDrawList.length;
for (i = 0; i < childComponentListLength; i++) {
childComponent = oldDrawList[i];
if (drawLogger.isDebug) {
drawLogger.debug("Parent Component " + (this.element != null ? this.element.id : "") + " drawList length: " + oldDrawList.length);
}
childComponent._addedToDrawList = false;
if (drawLogger.isDebug) {
drawLogger.debug(this, "childComponent: " + childComponent.element + "; canDraw: " + childComponent.canDraw());
}
if (childComponent.canDraw()) { // TODO if canDraw is false when does needsDraw get reset?
childComponent._drawIfNeeded(level+1);
}
}
}
}
},
_updateComponentDom: {
value: function() {
var component, composer, length, i;
if (this._firstDraw) {
if (this.parentComponent && typeof this.parentComponent.childComponentWillPrepareForDraw === "function") {
this.parentComponent.childComponentWillPrepareForDraw(this);
}
this._prepareForDraw();
if (this.prepareForDraw) {
this.prepareForDraw();
}
// Load any non lazyLoad composers that have been added
length = this.composerList.length;
for (i = 0; i < length; i++) {
composer = this.composerList[i];
if (!composer.lazyLoad) {
composer._load();
}
}
// Will we expose a different property, firstDraw, for components to check
this._firstDraw = false;
}
if (this._newDomContent !== null || this._shouldClearDomContentOnNextDraw) {
if (drawLogger.isDebug) {
logger.debug("Component content changed: component ", this._montage_metadata.objectName, this.identifier, " newDomContent", this._newDomContent);
}
this._performDomContentChanges();
}
}
},
/**
Description TODO
@private
*/
_replaceElementWithTemplate: {
enumerable: false,
value: function() {
var element = this.element,
template = this._templateElement,
attributes = this.element.attributes,
attributeName,
value,
i,
attribute;
// TODO: get a spec for this, what attributes should we merge?
for (i = 0; (attribute = attributes[i]); i++) {
attributeName = attribute.nodeName;
if (attributeName === "id" || attributeName === "data-montage-id") {
continue;
} else {
value = (template.getAttribute(attributeName) || "") + (attributeName === "style" ? "; " : " ") +
attribute.nodeValue;
}
template.setAttribute(attributeName, value);
}
if (element.parentNode) {
element.parentNode.replaceChild(template, element);
} else {
console.warn("Warning: Trying to replace element ", element," which has no parentNode");
}
this.eventManager.unregisterEventHandlerForElement(element);
this.eventManager.registerEventHandlerForElement(this, template);
this._element = template;
this._templateElement = null;
}
},
/**
Description TODO
@private
*/
_prepareForDraw: {
value: function _prepareForDraw() {
if (logger.isDebug) {
logger.debug(this, "_templateElement: " + this._templateElement);
}
if (this._templateElement) {
this._replaceElementWithTemplate();
}
// This will schedule a second draw for any component that has children
var childComponents = this.childComponents;
for (var i = 0, childComponent; (childComponent = childComponents[i]); i++) {
if (drawLogger.isDebug) {
drawLogger.debug(this, "needsDraw = true for: " + childComponent._montage_metadata.exportedSymbol);
}
childComponent.needsDraw = true;
}
},
enumerable: false
},
/**
Description TODO
@type {Property}
@default null
*/
prepareForActivationEvents: {
enumerable: false,
value: null
},
/**
* Called to add event listeners on demand
* @type function
* @private
*/
_prepareForActivationEvents: {
value: function() {
var i = this.composerList.length, composer;
for (i = 0; i < this.composerList.length; i++) {
composer = this.composerList[i];
if (composer.lazyLoad) {
composer._load();
}
}
if (typeof this.prepareForActivationEvents === "function") {
this.prepareForActivationEvents();
}
}
},
/**
Description TODO
@private
*/
_performDomContentChanges: {
value: function() {
var contents = this._newDomContent,
oldContent = this._element.childNodes[0],
element;
if (contents || this._shouldClearDomContentOnNextDraw) {
element = this._element;
element.innerHTML = "";
if (contents instanceof Element) {
element.appendChild(contents);
} else if(contents !== null) {
for (var i = 0, content; (content = contents[i]); i++) {
element.appendChild(content);
}
}
this._newDomContent = null;
if (typeof this.contentDidChange === "function") {
this.contentDidChange(this._element.childNodes[0], oldContent);
}
this._shouldClearDomContentOnNextDraw = false;
}
}
},
/**
This method is called so that the callee can insert or remove nodes from the DOMontage.
@function
*/
draw: {
enumerable: false,
value: function() {
}
},
/**
Description TODO
@type {Property}
@default null
*/
willDraw: {
enumerable: false,
value: null
},
/**
This method is called once all the components that could draw in this loop have done so.
@function
*/
didDraw: {
enumerable: false,
value: function() {
}
},
/**
Records wether or not we have been added to the parent's drawList.
@private
*/
_addedToDrawList: {
value: false
},
/**
Description TODO
@private
*/
_addToParentsDrawList: {
enumerable: false,
value: function() {
if (!this._addedToDrawList) {
var parentComponent = this.parentComponent;
if (!parentComponent) {
if (drawLogger.isDebug) {
drawLogger.debug(this, "parentComponent is null");
}
} else {
parentComponent._addToDrawList(this);
}
if (drawLogger.isDebug) {
drawLogger.debug("drawList -- childComponent",this._montage_metadata.objectName," added to ",parentComponent._montage_metadata.objectName);
}
}
}
},
/**
Backing property for needsDraw.
@private
*/
_needsDraw: {
enumerable: false,
value: false
},
/**
The purpose of this property is to trigger the adding of the component to the draw list and maintain whether draw needs to be called as a consequence of drawIfNeeded.
@type {Function}
@default {Boolean} false
*/
needsDraw: {
enumerable: true,
get: function() {
return !!this._needsDraw;
},
set: function(value) {
if (this.isDeserializing) {
// Ignore needsDraw(s) which happen during deserialization
return;
}
if (this._needsDraw !== value) {
if (drawLogger.isDebug) {
drawLogger.debug("NEEDS DRAW TOGGLED " + value + " FOR " + this._montage_metadata.objectName);
}
this._needsDraw = !!value;
if (value) {
if (this.canDrawGate.value) {
this._addToParentsDrawList();
} else {
this.blockDrawGate.setField("drawRequested", true);
}
} else {
}
}
}
},
/**
Contains the list of childComponents this instance is reponsible for drawing.
@private
*/
_drawList: {
enumerable: true,
value: null
},
/**
Description TODO
@private
*/
__addToDrawList: {
enumerable: false,
value: function(childComponent) {
if (this._drawList === null) {
this._drawList = [childComponent];
childComponent._addedToDrawList = true;
} else {
if (this._drawList.indexOf(childComponent) === -1) {
this._drawList.push(childComponent);
childComponent._addedToDrawList = true;
}
}
}
},
/**
Adds the passed in child component to the drawList