'use strict';
exports.__esModule = true;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _utils = require('../utils');
var _DisplayObject2 = require('./DisplayObject');
var _DisplayObject3 = _interopRequireDefault(_DisplayObject2);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
/**
* A Container represents a collection of display objects.
* It is the base class of all display objects that act as a container for other objects.
*
*```js
* let container = new PIXI.Container();
* container.addChild(sprite);
* ```
*
* @class
* @extends PIXI.DisplayObject
* @memberof PIXI
*/
var Container = function (_DisplayObject) {
_inherits(Container, _DisplayObject);
/**
*
*/
function Container() {
_classCallCheck(this, Container);
/**
* The array of children of this container.
*
* @member {PIXI.DisplayObject[]}
* @readonly
*/
var _this = _possibleConstructorReturn(this, _DisplayObject.call(this));
_this.children = [];
return _this;
}
/**
* Overridable method that can be used by Container subclasses whenever the children array is modified
*
* @private
*/
Container.prototype.onChildrenChange = function onChildrenChange() {}
/* empty */
/**
* Adds one or more children to the container.
*
* Multiple items can be added like so: `myContainer.addChild(thingOne, thingTwo, thingThree)`
*
* @param {...PIXI.DisplayObject} child - The DisplayObject(s) to add to the container
* @return {PIXI.DisplayObject} The first child that was added.
*/
;
Container.prototype.addChild = function addChild(child) {
var argumentsLength = arguments.length;
// if there is only one argument we can bypass looping through the them
if (argumentsLength > 1) {
// loop through the arguments property and add all children
// use it the right way (.length and [i]) so that this function can still be optimised by JS runtimes
for (var i = 0; i < argumentsLength; i++) {
this.addChild(arguments[i]);
}
} else {
// if the child has a parent then lets remove it as Pixi objects can only exist in one place
if (child.parent) {
child.parent.removeChild(child);
}
child.parent = this;
// ensure child transform will be recalculated
child.transform._parentID = -1;
this.children.push(child);
// ensure bounds will be recalculated
this._boundsID++;
// TODO - lets either do all callbacks or all events.. not both!
this.onChildrenChange(this.children.length - 1);
child.emit('added', this);
}
return child;
};
/**
* Adds a child to the container at a specified index. If the index is out of bounds an error will be thrown
*
* @param {PIXI.DisplayObject} child - The child to add
* @param {number} index - The index to place the child in
* @return {PIXI.DisplayObject} The child that was added.
*/
Container.prototype.addChildAt = function addChildAt(child, index) {
if (index < 0 || index > this.children.length) {
throw new Error(child + 'addChildAt: The index ' + index + ' supplied is out of bounds ' + this.children.length);
}
if (child.parent) {
child.parent.removeChild(child);
}
child.parent = this;
// ensure child transform will be recalculated
child.transform._parentID = -1;
this.children.splice(index, 0, child);
// ensure bounds will be recalculated
this._boundsID++;
// TODO - lets either do all callbacks or all events.. not both!
this.onChildrenChange(index);
child.emit('added', this);
return child;
};
/**
* Swaps the position of 2 Display Objects within this container.
*
* @param {PIXI.DisplayObject} child - First display object to swap
* @param {PIXI.DisplayObject} child2 - Second display object to swap
*/
Container.prototype.swapChildren = function swapChildren(child, child2) {
if (child === child2) {
return;
}
var index1 = this.getChildIndex(child);
var index2 = this.getChildIndex(child2);
this.children[index1] = child2;
this.children[index2] = child;
this.onChildrenChange(index1 < index2 ? index1 : index2);
};
/**
* Returns the index position of a child DisplayObject instance
*
* @param {PIXI.DisplayObject} child - The DisplayObject instance to identify
* @return {number} The index position of the child display object to identify
*/
Container.prototype.getChildIndex = function getChildIndex(child) {
var index = this.children.indexOf(child);
if (index === -1) {
throw new Error('The supplied DisplayObject must be a child of the caller');
}
return index;
};
/**
* Changes the position of an existing child in the display object container
*
* @param {PIXI.DisplayObject} child - The child DisplayObject instance for which you want to change the index number
* @param {number} index - The resulting index number for the child display object
*/
Container.prototype.setChildIndex = function setChildIndex(child, index) {
if (index < 0 || index >= this.children.length) {
throw new Error('The supplied index is out of bounds');
}
var currentIndex = this.getChildIndex(child);
(0, _utils.removeItems)(this.children, currentIndex, 1); // remove from old position
this.children.splice(index, 0, child); // add at new position
this.onChildrenChange(index);
};
/**
* Returns the child at the specified index
*
* @param {number} index - The index to get the child at
* @return {PIXI.DisplayObject} The child at the given index, if any.
*/
Container.prototype.getChildAt = function getChildAt(index) {
if (index < 0 || index >= this.children.length) {
throw new Error('getChildAt: Index (' + index + ') does not exist.');
}
return this.children[index];
};
/**
* Removes one or more children from the container.
*
* @param {...PIXI.DisplayObject} child - The DisplayObject(s) to remove
* @return {PIXI.DisplayObject} The first child that was removed.
*/
Container.prototype.removeChild = function removeChild(child) {
var argumentsLength = arguments.length;
// if there is only one argument we can bypass looping through the them
if (argumentsLength > 1) {
// loop through the arguments property and add all children
// use it the right way (.length and [i]) so that this function can still be optimised by JS runtimes
for (var i = 0; i < argumentsLength; i++) {
this.removeChild(arguments[i]);
}
} else {
var index = this.children.indexOf(child);
if (index === -1) return null;
child.parent = null;
// ensure child transform will be recalculated
child.transform._parentID = -1;
(0, _utils.removeItems)(this.children, index, 1);
// ensure bounds will be recalculated
this._boundsID++;
// TODO - lets either do all callbacks or all events.. not both!
this.onChildrenChange(index);
child.emit('removed', this);
}
return child;
};
/**
* Removes a child from the specified index position.
*
* @param {number} index - The index to get the child from
* @return {PIXI.DisplayObject} The child that was removed.
*/
Container.prototype.removeChildAt = function removeChildAt(index) {
var child = this.getChildAt(index);
// ensure child transform will be recalculated..
child.parent = null;
child.transform._parentID = -1;
(0, _utils.removeItems)(this.children, index, 1);
// ensure bounds will be recalculated
this._boundsID++;
// TODO - lets either do all callbacks or all events.. not both!
this.onChildrenChange(index);
child.emit('removed', this);
return child;
};
/**
* Removes all children from this container that are within the begin and end indexes.
*
* @param {number} [beginIndex=0] - The beginning position.
* @param {number} [endIndex=this.children.length] - The ending position. Default value is size of the container.
* @returns {DisplayObject[]} List of removed children
*/
Container.prototype.removeChildren = function removeChildren() {
var beginIndex = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
var endIndex = arguments[1];
var begin = beginIndex;
var end = typeof endIndex === 'number' ? endIndex : this.children.length;
var range = end - begin;
var removed = void 0;
if (range > 0 && range <= end) {
removed = this.children.splice(begin, range);
for (var i = 0; i < removed.length; ++i) {
removed[i].parent = null;
if (removed[i].transform) {
removed[i].transform._parentID = -1;
}
}
this._boundsID++;
this.onChildrenChange(beginIndex);
for (var _i = 0; _i < removed.length; ++_i) {
removed[_i].emit('removed', this);
}
return removed;
} else if (range === 0 && this.children.length === 0) {
return [];
}
throw new RangeError('removeChildren: numeric values are outside the acceptable range.');
};
/**
* Updates the transform on all children of this container for rendering
*/
Container.prototype.updateTransform = function updateTransform() {
this._boundsID++;
this.transform.updateTransform(this.parent.transform);
// TODO: check render flags, how to process stuff here
this.worldAlpha = this.alpha * this.parent.worldAlpha;
for (var i = 0, j = this.children.length; i < j; ++i) {
var child = this.children[i];
if (child.visible) {
child.updateTransform();
}
}
};
/**
* Recalculates the bounds of the container.
*
*/
Container.prototype.calculateBounds = function calculateBounds() {
this._bounds.clear();
this._calculateBounds();
for (var i = 0; i < this.children.length; i++) {
var child = this.children[i];
if (!child.visible || !child.renderable) {
continue;
}
child.calculateBounds();
// TODO: filter+mask, need to mask both somehow
if (child._mask) {
child._mask.calculateBounds();
this._bounds.addBoundsMask(child._bounds, child._mask._bounds);
} else if (child.filterArea) {
this._bounds.addBoundsArea(child._bounds, child.filterArea);
} else {
this._bounds.addBounds(child._bounds);
}
}
this._lastBoundsID = this._boundsID;
};
/**
* Recalculates the bounds of the object. Override this to
* calculate the bounds of the specific object (not including children).
*
*/
Container.prototype._calculateBounds = function _calculateBounds() {}
// FILL IN//
/**
* Renders the object using the WebGL renderer
*
* @param {PIXI.WebGLRenderer} renderer - The renderer
*/
;
Container.prototype.renderWebGL = function renderWebGL(renderer) {
// if the object is not visible or the alpha is 0 then no need to render this element
if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
return;
}
// do a quick check to see if this element has a mask or a filter.
if (this._mask || this._filters) {
this.renderAdvancedWebGL(renderer);
} else {
this._renderWebGL(renderer);
// simple render children!
for (var i = 0, j = this.children.length; i < j; ++i) {
this.children[i].renderWebGL(renderer);
}
}
};
/**
* Render the object using the WebGL renderer and advanced features.
*
* @private
* @param {PIXI.WebGLRenderer} renderer - The renderer
*/
Container.prototype.renderAdvancedWebGL = function renderAdvancedWebGL(renderer) {
renderer.flush();
var filters = this._filters;
var mask = this._mask;
// push filter first as we need to ensure the stencil buffer is correct for any masking
if (filters) {
if (!this._enabledFilters) {
this._enabledFilters = [];
}
this._enabledFilters.length = 0;
for (var i = 0; i < filters.length; i++) {
if (filters[i].enabled) {
this._enabledFilters.push(filters[i]);
}
}
if (this._enabledFilters.length) {
renderer.filterManager.pushFilter(this, this._enabledFilters);
}
}
if (mask) {
renderer.maskManager.pushMask(this, this._mask);
}
// add this object to the batch, only rendered if it has a texture.
this._renderWebGL(renderer);
// now loop through the children and make sure they get rendered
for (var _i2 = 0, j = this.children.length; _i2 < j; _i2++) {
this.children[_i2].renderWebGL(renderer);
}
renderer.flush();
if (mask) {
renderer.maskManager.popMask(this, this._mask);
}
if (filters && this._enabledFilters && this._enabledFilters.length) {
renderer.filterManager.popFilter();
}
};
/**
* To be overridden by the subclasses.
*
* @private
* @param {PIXI.WebGLRenderer} renderer - The renderer
*/
Container.prototype._renderWebGL = function _renderWebGL(renderer) // eslint-disable-line no-unused-vars
{}
// this is where content itself gets rendered...
/**
* To be overridden by the subclass
*
* @private
* @param {PIXI.CanvasRenderer} renderer - The renderer
*/
;
Container.prototype._renderCanvas = function _renderCanvas(renderer) // eslint-disable-line no-unused-vars
{}
// this is where content itself gets rendered...
/**
* Renders the object using the Canvas renderer
*
* @param {PIXI.CanvasRenderer} renderer - The renderer
*/
;
Container.prototype.renderCanvas = function renderCanvas(renderer) {
// if not visible or the alpha is 0 then no need to render this
if (!this.visible || this.worldAlpha <= 0 || !this.renderable) {
return;
}
if (this._mask) {
renderer.maskManager.pushMask(this._mask);
}
this._renderCanvas(renderer);
for (var i = 0, j = this.children.length; i < j; ++i) {
this.children[i].renderCanvas(renderer);
}
if (this._mask) {
renderer.maskManager.popMask(renderer);
}
};
/**
* Removes all internal references and listeners as well as removes children from the display list.
* Do not use a Container after calling `destroy`.
*
* @param {object|boolean} [options] - Options parameter. A boolean will act as if all options
* have been set to that value
* @param {boolean} [options.children=false] - if set to true, all the children will have their destroy
* method called as well. 'options' will be passed on to those calls.
* @param {boolean} [options.texture=false] - Only used for child Sprites if options.children is set to true
* Should it destroy the texture of the child sprite
* @param {boolean} [options.baseTexture=false] - Only used for child Sprites if options.children is set to true
* Should it destroy the base texture of the child sprite
*/
Container.prototype.destroy = function destroy(options) {
_DisplayObject.prototype.destroy.call(this);
var destroyChildren = typeof options === 'boolean' ? options : options && options.children;
var oldChildren = this.removeChildren(0, this.children.length);
if (destroyChildren) {
for (var i = 0; i < oldChildren.length; ++i) {
oldChildren[i].destroy(options);
}
}
};
/**
* The width of the Container, setting this will actually modify the scale to achieve the value set
*
* @member {number}
*/
_createClass(Container, [{
key: 'width',
get: function get() {
return this.scale.x * this.getLocalBounds().width;
},
set: function set(value) // eslint-disable-line require-jsdoc
{
var width = this.getLocalBounds().width;
if (width !== 0) {
this.scale.x = value / width;
} else {
this.scale.x = 1;
}
this._width = value;
}
/**
* The height of the Container, setting this will actually modify the scale to achieve the value set
*
* @member {number}
*/
}, {
key: 'height',
get: function get() {
return this.scale.y * this.getLocalBounds().height;
},
set: function set(value) // eslint-disable-line require-jsdoc
{
var height = this.getLocalBounds().height;
if (height !== 0) {
this.scale.y = value / height;
} else {
this.scale.y = 1;
}
this._height = value;
}
}]);
return Container;
}(_DisplayObject3.default);
// performance increase to avoid using call.. (10x faster)
exports.default = Container;
Container.prototype.containerUpdateTransform = Container.prototype.updateTransform;
//# sourceMappingURL=Container.js.map
