avocado-old/packages/graphics/container.js

const PIXI = 'undefined' !== typeof window ? require('pixi.js') : undefined;

import {Renderable} from './renderable';

export class Container extends Renderable {

  constructor() {
    super();
    this._children = [];
    this._childrenIndexes = new Map();
    this._isDirty = false;
    this.container = PIXI ? new PIXI.Container() : undefined;
  }

  addChild(child) {
    child.parent = this;
    this.isDirty = true;
    const index = this._children.push(child) - 1;
    this._childrenIndexes.set(child, index);
    this.container.addChild(child.internal);
  }

  get children() {
    return this._children;
  }

  destroy() {
    this.children.forEach((child) => {
      child.destroy();
    });
    super.destroy();
  }

  get internal() {
    return this.container;
  }

  get isDirty() {
    return this._isDirty;
  }

  set isDirty(isDirty) {
    if (this.parent) {
      this.parent.isDirty = isDirty;
    }
    this._isDirty = isDirty;
  }

  _removeChild(child) {
    const index = this._children.indexOf(child);
    if (-1 === index) {
      return;
    }
    this._children.splice(index, 1);
    this.container.removeChild(child.internal);
  }

  removeChild(child) {
    this._removeChild(child);
    this._resetChildrenIndexes();
  }

  removeAllChildren() {
    for (const child of this._children) {
      this._removeChild(child);
    }
    this._childrenIndexes = new Map();
  }

  _resetChildrenIndexes() {
    this._childrenIndexes = new Map();
    for (const i in this._children) {
      const child = this._children[i];
      this._childrenIndexes.set(child, i);
    }
  }

  tick() {
    if (!this.isDirty) {
      return;
    }
    let needsSort = false;
    for (const child of this._children) {
      if (0 !== child.zIndex) {
        needsSort = true;
      }
      if (child instanceof Container) {
        child.tick();
      }
    }
    if (!needsSort) {
      return;
    }
    this._children.sort((l, r) => {
      if (l.zIndex !== r.zIndex) {
        return l.zIndex - r.zIndex;
      }
      const lIndex = this._childrenIndexes.get(l);
      const rIndex = this._childrenIndexes.get(r);
      return lIndex - rIndex;
    });
    this.container.children = this._children.map((child) => {
      return child.internal;
    });
    this._resetChildrenIndexes();
  }

}