Dart Documentationbot_retainedStage

Stage class

Extends

DisposableImpl > AttachableObject > Stage

Implements

ElementParent

Constructors

new Stage(CanvasElement _canvas, PElement _element) #

Stage(this._canvas, this._element) {
  _element.registerParent(this);
}

Methods

bool operator ==(other) #

inherited from Object

The equality operator.

The default behavior for all Objects is to return true if and only if this and other are the same object.

If a subclass overrides the equality operator it should override the hashCode method as well to maintain consistency.

bool operator ==(other) => identical(this, other);

void childInvalidated(PElement child) #

void childInvalidated(PElement child){
  validateNotDisposed();
  assert(child == _element);
  _invalidatedEventHandle.fireEvent(EventArgs.empty);
}

CanvasRenderingContext2D get ctx() #

CanvasRenderingContext2D get ctx {
  validateNotDisposed();
  if(_ctx == null) {
    _ctx = _canvas.context2d;
  }
  return _ctx;
}

void dispose() #

inherited from DisposableImpl
void dispose(){
  if (!_disposed) {
    // Set disposed_ to true first, in case during the chain of disposal this
    // gets disposed recursively.
    this._disposed = true;
    this.disposeInternal();
  }
}

void disposeInternal() #

Do not call this method directly. Call dispose instead. Subclasses should override this method to implement Disposable behavior.

docs inherited from DisposableImpl
void disposeInternal(){
  super.disposeInternal();
  _invalidatedEventHandle.dispose();
}

bool draw() #

bool draw(){
  validateNotDisposed();
  if (_ctx == null) {
    _ctx = _canvas.context2d;
  } else {
    this._ctx.clearRect(0, 0, this._canvas.width, this._canvas.height);
  }

  return this._element.draw(this._ctx);
}

AffineTransform getTransformToRoot() #

AffineTransform getTransformToRoot() => new AffineTransform();

int hashCode() #

inherited from Object

Get a hash code for this object.

All objects have hash codes. Hash codes are guaranteed to be the same for objects that are equal when compared using the equality operator ==. Other than that there are no guarantees about the hash codes. They will not be consistent between runs and there are no distribution guarantees.

If a subclass overrides hashCode it should override the equality operator as well to maintain consistency.

external int hashCode();

EventRoot<EventArgs> get invalidated() #

EventRoot<EventArgs> get invalidated => _invalidatedEventHandle;

bool get isDisposed() #

inherited from DisposableImpl
bool get isDisposed => _disposed;

noSuchMethod(String name, List args) #

inherited from Object

noSuchMethod is invoked when users invoke a non-existant method on an object. The name of the method and the arguments of the invocation are passed to noSuchMethod. If noSuchMethod returns a value, that value becomes the result of the original invocation.

The default behavior of noSuchMethod is to throw a noSuchMethodError.

external Dynamic noSuchMethod(String name, List args);

PElement get rootElement() #

PElement get rootElement => _element;

Type get runtimeType() #

inherited from Object

A representation of the runtime type of the object.

external Type get runtimeType;

Size get size() #

Size get size => new Size(_canvas.width, _canvas.height);

String toString() #

inherited from Object

Returns a string representation of this object.

external String toString();

void validateNotDisposed() #

inherited from DisposableImpl
void validateNotDisposed() {
  assert(!_disposed);
}