void addChild(DisplayObject child) {
 addChildAt(child, _children.length);
}

void addChildAt(DisplayObject child, int index) {

 if (index < 0 || index > _children.length) {
   throw new ArgumentError("Error #2006: The supplied index is out of bounds.");
 }

 if (child == this) {
   throw new ArgumentError("Error #2024: An object cannot be added as a child of itself.");
 }

 if (child.parent == this) {

   _children.remove(child);
   if (index > _children.length) index -= 1;
   _children.insert(index, child);

 } else {

   child.removeFromParent();

   for(var ancestor = this; ancestor != null; ancestor = ancestor.parent) {
     if (ancestor == child) {
       throw new ArgumentError("Error #2150: An object cannot be added as "
           "a child to one of it's children (or children's children, etc.).");
     }
   }

   _children.insert(index, child);

   child._parent = this;
   child.dispatchEvent(new Event(Event.ADDED, true));

   if (this.stage != null) {
     _dispatchEventDescendants(child, new Event(Event.ADDED_TO_STAGE));
   }
 }
}

StreamSubscription<Event> addEventListener(String eventType, EventListener eventListener, {
 bool useCapture: false, int priority: 0 }) {

 return this.on(eventType)._subscribe(eventListener, useCapture, priority);
}

void addTo(DisplayObjectContainer parent) {
 parent.addChild(this);
}

void applyCache(int x, int y, int width, int height, {bool debugBorder: false}) {

 var pixelRatio = Stage.autoHiDpi ? _devicePixelRatio : 1.0;

 if (_cacheTexture == null) {
   _cacheTexture = new RenderTexture(width, height, true, Color.Transparent, pixelRatio);
 } else {
   _cacheTexture.resize(width, height);
 }

 _cacheRectangle = new Rectangle(x, y, width, height);
 _cacheDebugBorder = debugBorder;

 refreshCache();
}

bool contains(DisplayObject child) {

 while(child != null) {
   if (child == this) return true;
   child = child.parent;
 }
 return false;
}

void dispatchEvent(Event event) {

 List<DisplayObject> ancestors = null;

 if (event.captures || event.bubbles) {
   for(DisplayObject ancestor = parent; ancestor != null; ancestor = ancestor.parent) {
     if(ancestor._hasPropagationEventListeners(event)) {
       if (ancestors == null) ancestors = [];
       ancestors.add(ancestor);
     }
   }
 }

 if (ancestors != null && event.captures) {
   for(int i = ancestors.length - 1 ; i >= 0; i--) {
     ancestors[i]._dispatchEventInternal(event, this, EventPhase.CAPTURING_PHASE);
     if (event.stopsPropagation) return;
   }
 }

 _dispatchEventInternal(event, this, EventPhase.AT_TARGET);
 if (event.stopsPropagation) return;

 if (ancestors != null && event.bubbles) {
   for(int i = 0; i < ancestors.length; i++) {
     ancestors[i]._dispatchEventInternal(event, this, EventPhase.BUBBLING_PHASE);
     if (event.stopsPropagation) return;
   }
 }
}

Rectangle getBounds(DisplayObject targetSpace) {

 Rectangle returnRectangle = new Rectangle.zero();
 Matrix matrix = (targetSpace == null) ? transformationMatrix : transformationMatrixTo(targetSpace);

 return (matrix != null) ? getBoundsTransformed(matrix, returnRectangle) : returnRectangle;
}

Rectangle getBoundsTransformed(Matrix matrix, [Rectangle returnRectangle]) {
 
 if (returnRectangle == null)
   returnRectangle = new Rectangle.zero();
 
 super.getBoundsTransformed(matrix, returnRectangle);
 
 if (_graphics != null) {
   returnRectangle = _graphics._getBoundsTransformed(matrix).union(returnRectangle);
 }
 
 return returnRectangle;
}

dynamic getChildAt(int index) {

 if (index < 0 || index >= _children.length) {
   throw new ArgumentError("Error #2006: The supplied index is out of bounds.");
 }
 return _children[index];
}

dynamic getChildByName(String name) {

 for(int i = 0; i < _children.length; i++) {
   DisplayObject child = _children[i];
   if (child.name == name) return child;
 }
 return null;
}

int getChildIndex(DisplayObject child) {

 return _children.indexOf(child);
}

Point globalToLocal(Point globalPoint) {

 _tmpMatrix.identity();

 for(var current = this; current != null; current = current._parent) {
   _tmpMatrix.concat(current.transformationMatrix);
 }

 _tmpMatrix.invert();

 return _tmpMatrix.transformPoint(globalPoint);
}

bool hasEventListener(String eventType) {

 var eventStreams = _eventStreams;
 if (eventStreams == null) return false;
 var eventStream = eventStreams[eventType];
 if (eventStream == null) return false;

 return eventStream.hasSubscriptions;
}

DisplayObject hitTestInput(num localX, num localY) {
 
 DisplayObject target = null;
 
 if (this.hitArea != null) {
   
   var matrix = this.transformationMatrixTo(this.hitArea);
   if (matrix != null) {
     double hitAreaX = localX * matrix.a + localY * matrix.c + matrix.tx;
     double hitAreaY = localX * matrix.b + localY * matrix.d + matrix.ty;
     
     if (this.hitArea.hitTestInput(hitAreaX, hitAreaY) != null) {
       target = this;
     }
   }

 } else {
 
   target = super.hitTestInput(localX, localY);
   
   if (target == null && _graphics != null) {
     if (_graphics._hitTestInput(localX, localY)) {
       target = this;
     }
   } 
 }
 
 return target;
}

bool hitTestObject(DisplayObject other) {

 var stage1 = this.stage;
 var stage2 = other.stage;

 if (stage1 == null || stage2 == null || stage1 != stage2) return false;

 var rect1 = this.getBounds(stage1);
 var rect2 = other.getBounds(stage2);

 return rect1.intersects(rect2);
}

bool hitTestPoint(num x, num y, [bool shapeFlag = false]) {

 var stage = this.stage;
 if (stage == null) return false;

 if (shapeFlag) {
   var matrix = stage.transformationMatrixTo(this);
   if (matrix == null) return false;

   var stagePoint = new Point(x, y);
   var localPoint = matrix.transformPoint(stagePoint);

   return this.hitTestInput(localPoint.x, localPoint.y) != null;

 } else {

   var rect = this.getBounds(stage);
   return rect.contains(x, y);
 }
}

Point localToGlobal(Point localPoint) {

 _tmpMatrix.identity();

 for(var current = this; current != null; current = current._parent) {
   _tmpMatrix.concat(current.transformationMatrix);
 }

 return _tmpMatrix.transformPoint(localPoint);
}

EventStream<Event> on(String eventType) {

 var eventStreams = _eventStreams;
 if (eventStreams == null) {
   eventStreams = new Map<String, EventStream>();
   _eventStreams = eventStreams;
 }

 var eventStream = eventStreams[eventType];
 if (eventStream == null) {
   eventStream = new EventStream._internal(this, eventType);
   eventStreams[eventType] = eventStream;
 }

 return eventStream;
}

void refreshCache() {

 if (_cacheTexture == null) return;

 var x = _cacheRectangle.x;
 var y = _cacheRectangle.y;
 var width = _cacheRectangle.width;
 var height = _cacheRectangle.height;
 var canvas = _cacheTexture.canvas;

 var matrix = _cacheTexture.quad.drawMatrix..translate(-x, -y);
 var renderContext = new RenderContextCanvas(canvas, Color.Transparent);
 var renderState = new RenderState(renderContext, matrix);

 renderContext.clear();
 render(renderState);

 if (_filters != null) {
   var cacheBitmapData = new BitmapData.fromRenderTextureQuad(_cacheTexture.quad);
   var bounds = this.getBoundsTransformed(_identityMatrix)..offset(-x, -y);
   for(var filter in _filters) {
     var filterOverlap = filter.overlap;
     var filterBounds = bounds.clone();
     filterBounds.offset(filterOverlap.x, filterOverlap.y);
     filterBounds.inflate(filterOverlap.width, filterOverlap.height);
     filter.apply(cacheBitmapData, filterBounds.align());
   }
 }

 if (_cacheDebugBorder) {
   canvas.context2D
       ..setTransform(1.0, 0.0, 0.0, 1.0, 0.0, 0.0)
       ..lineWidth = 1
       ..lineJoin = "miter"
       ..lineCap = "butt"
       ..strokeStyle = "#FF00FF"
       ..strokeRect(0.5, 0.5, canvas.width - 1, canvas.height - 1);
 }

 _cacheTexture.update();
}

void removeCache() {
 if (_cacheTexture != null) {
   _cacheTexture.dispose();
   _cacheTexture = null;
 }
}

void removeChild(DisplayObject child) {

 int childIndex = _children.indexOf(child);
 if (childIndex == -1) {
   throw new ArgumentError(
       "Error #2025: The supplied DisplayObject must be a child of the caller.");
 }

 removeChildAt(childIndex);
}

void removeChildAt(int index) {

 if (index < 0 || index >= _children.length) {
   throw new ArgumentError("Error #2006: The supplied index is out of bounds.");
 }

 DisplayObject child = _children[index];

 child.dispatchEvent(new Event(Event.REMOVED, true));

 if (this.stage != null) {
   _dispatchEventDescendants(child, new Event(Event.REMOVED_FROM_STAGE));
 }

 child._parent = null;
 _children.removeAt(index);
}

void removeChildren([int beginIndex = 0, int endIndex = 0x7fffffff]) {

 var length = _children.length;
 if (length == 0) return;

 if (endIndex == 0x7fffffff) {
   endIndex = length - 1;
 }

 if (beginIndex < 0 || endIndex < 0 || beginIndex >= length || endIndex >= length) {
   throw new ArgumentError("Error #2006: The supplied index is out of bounds.");
 }

 for(int i = beginIndex; i <= endIndex; i++) {
   if (beginIndex >= _children.length) break;
   removeChildAt(beginIndex);
 }
}

void removeEventListener(String eventType, EventListener eventListener, {
 bool useCapture: false }) {

 this.on(eventType)._unsubscribe(eventListener, useCapture);
}

void removeEventListeners(String eventType) {
 this.on(eventType).cancelSubscriptions();
}

void removeFromParent() {
 if (_parent != null)
   _parent.removeChild(this);
}

void setChildIndex(DisplayObject child, int index) {

 if (index < 0 || index >= _children.length) {
   throw new ArgumentError("Error #2006: The supplied index is out of bounds.");
 }

 int oldIndex = getChildIndex(child);
 if (oldIndex == -1) {
   throw new ArgumentError("Error #2025: The supplied DisplayObject must be a child of the caller.");
 }

 _children.removeAt(oldIndex);
 _children.insert(index, child);
}

void setTransform(num x, num y, [num scaleX, num scaleY, num rotation, num skewX, num skewY, num pivotX, num pivotY]) {
 if (x is num) _x = x;
 if (y is num) _y = y;
 if (scaleX is num) _scaleX = scaleX;
 if (scaleY is num) _scaleY = scaleY;
 if (rotation is num) _rotation = rotation;
 if (skewX is num) _skewX = skewX;
 if (skewY is num) _skewY = skewY;
 if (pivotX is num) _pivotX = pivotX;
 if (pivotY is num) _pivotY = pivotY;
 _transformationMatrixRefresh = true;
}

void sortChildren(Function compareFunction) {
 _children.sort(compareFunction);
}

startDrag([bool lockCenter = false, Rectangle bounds = null]) {
 
 Mouse._dragSprite = this;
 Mouse._dragSpriteBounds = bounds;
 
 if (lockCenter) {
   Mouse._dragSpriteCenter = this.getBoundsTransformed(_identityMatrix).center;
 } else {
   var mp = this.mousePosition;
   Mouse._dragSpriteCenter = (mp != null) ? mp : new Point.zero();
 }

 _updateDrag();
}

stopDrag() {
 
 if (Mouse._dragSprite == this) {
   Mouse._dragSprite = null;
   Mouse._dragSpriteCenter = null;
   Mouse._dragSpriteBounds = null;
 }
}

void swapChildren(DisplayObject child1, DisplayObject child2) {

 int index1 = getChildIndex(child1);
 int index2 = getChildIndex(child2);

 if (index1 == -1 || index2 == -1) {
   throw new ArgumentError("Error #2025: The supplied DisplayObject must be a child of the caller.");
 }

 swapChildrenAt(index1, index2);
}

void swapChildrenAt(int index1, int index2) {

 DisplayObject child1 = getChildAt(index1);
 DisplayObject child2 = getChildAt(index2);
 _children[index1] = child2;
 _children[index2] = child1;
}

Matrix transformationMatrixTo(DisplayObject targetSpace) {

 if (targetSpace == _parent) {
   return this.transformationMatrix.clone();
 }

 if (targetSpace != null && targetSpace._parent == this) {
   return targetSpace.transformationMatrix.cloneInvert();
 }

 //------------------------------------------------

 Matrix resultMatrix = new Matrix.fromIdentity();
 DisplayObject resultObject = this;

 while(resultObject != targetSpace && resultObject._parent != null) {
   resultMatrix.concat(resultObject.transformationMatrix);
   resultObject = resultObject._parent;
 }

 if (targetSpace == null && resultObject != null) {
   resultMatrix.concat(resultObject.transformationMatrix);
   resultObject = null;
 }

 if (resultObject == targetSpace)
   return resultMatrix;

 //------------------------------------------------

 Matrix targetMatrix = new Matrix.fromIdentity();
 DisplayObject targetObject = targetSpace;

 while(targetObject != this && targetObject._parent != null) {
   targetMatrix.concat(targetObject.transformationMatrix);
   targetObject = targetObject._parent;
 }

 targetMatrix.invert();

 if (targetObject == this) {
   return targetMatrix;
 }

 if (targetObject != resultObject) {
   return null;
 }

 resultMatrix.concat(targetMatrix);

 return resultMatrix;
}