bool get off => _off;

bool get visible => _visible;

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();
}

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();

 returnRectangle.x = matrix.tx;
 returnRectangle.y = matrix.ty;
 returnRectangle.width = 0;
 returnRectangle.height = 0;

 return returnRectangle;
}

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) {

 if (getBoundsTransformed(_identityMatrix).contains(localX, localY))
   return this;

 return null;
}

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 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 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;
}

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;
}