PCanvas class
Extends
DisposableImpl > AttachableObject > PElement > ElementParentImpl > Panel > PCanvas
Constructors
new PCanvas(int w, int h, [bool enableCache = false]) #
PCanvas(int w, int h, [bool enableCache = false]):super(w, h, enableCache);
Fields
Methods
bool operator ==(other) #
The equality operator.
The default behavior for all Object
s 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 addElement(PElement element) #
void addElement(PElement element){ insertAt(element, _children.length); }
AffineTransform addTransform() #
AffineTransform addTransform(){ validateNotDisposed(); var tx = new AffineTransform(); _transforms.add(tx); return tx; }
void childInvalidated(PElement child) #
void childInvalidated(PElement child){ assert(hasVisualChild(child)); invalidateDraw(); }
void dispose() #
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.
void disposeInternal(){ super.disposeInternal(); _updatedEventHandle.dispose(); _invalidatedEventHandle.dispose(); }
bool draw(CanvasRenderingContext2D ctx) #
bool draw(CanvasRenderingContext2D ctx){ update(); var dirty = (_lastDrawSize == null); drawCore(ctx); return dirty; }
void drawCore(CanvasRenderingContext2D ctx) #
void drawCore(CanvasRenderingContext2D ctx){ if(cacheEnabled) { _drawCached(ctx); } else { _drawNormal(ctx); } }
void drawOverride(CanvasRenderingContext2D ctx) #
void drawOverride(CanvasRenderingContext2D ctx) { if(background != null) { ctx.fillStyle = background; ctx.fillRect(0, 0, width, height); } super.drawOverride(ctx); }
Coordinate getCenter(PElement element) #
Coordinate getCenter(PElement element){ var sizeOffset = new Vector(element.width/2, element.height/2); return sizeOffset + getTopLeft(element); }
AffineTransform getChildTransform(child) #
AffineTransform getChildTransform(child) { assert(hasVisualChild(child)); var tx = _containerTransformProperty.get(child); assert(tx != null); return tx; }
Coordinate getTopLeft(PElement element) #
Coordinate getTopLeft(PElement element){ var tx = getChildTransform(element); return tx.transformCoordinate(); }
AffineTransform getTransform() #
AffineTransform getTransform() { var tx = new AffineTransform(); _transforms.forEach(tx.concatenate); return tx; }
AffineTransform getTransformToRoot() #
AffineTransform getTransformToRoot(){ var tx = new AffineTransform(); if(_parent != null){ tx.concatenate(_parent.getTransformToRoot()); } tx.concatenate(getTransform()); return tx; }
PElement getVisualChild(index) #
PElement getVisualChild(index) => _children[index];
int hashCode() #
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();
bool hasVisualChild(PElement element) #
bool hasVisualChild(PElement element){ var length = visualChildCount; for(var i=0;i<length;i++){ if(identical(element, getVisualChild(i))){ return true; } } return false; }
void set height(num value) #
void set height(num value) { assert(isValidNumber(value)); _height = value; invalidateDraw(); }
void insertAt(PElement element, [int index = null]) #
void insertAt(PElement element, [int index=null]){ index = (index == null) ? 0 : index; element.registerParent(this); _children.insertRange(index, 1, element); assert(!_containerTransformProperty.isSet(element)); _containerTransformProperty.set(element, element.addTransform()); onChildrenChanged(); }
EventRoot<EventArgs> get invalidated() #
EventRoot<EventArgs> get invalidated => _invalidatedEventHandle;
void invalidateDraw() #
void invalidateDraw(){ validateNotDisposed(); if(_lastDrawSize != null){ _lastDrawSize = null; _invalidateParent(); } }
noSuchMethod(String name, List args) #
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);
void onChildrenChanged() #
void onChildrenChanged(){ invalidateDraw(); }
void registerParent(ElementParent parent) #
void registerParent(ElementParent parent) { assert(_parent == null); assert(parent != null); _parent = parent; }
Type get runtimeType() #
A representation of the runtime type of the object.
external Type get runtimeType;
void setCenter(PElement element, Coordinate value) #
void setCenter(PElement element, Coordinate value){ var sizeOffset = new Vector(element.width/2, element.height/2); var delta = Coordinate.difference(value, sizeOffset); setTopLeft(element, delta); }
void setTopLeft(PElement element, Coordinate value) #
void setTopLeft(PElement element, Coordinate value){ var tx = getChildTransform(element); tx.setToTranslation(value.x, value.y); }
void set size(Size value) #
void set size(Size value) { assert(value.isValid); _width = value.width; _height = value.height; invalidateDraw(); }
String toString() #
Returns a string representation of this object.
external String toString();
void update() #
void update(){ _forEach((e) => e.update()); super.update(); }
EventRoot<EventArgs> get updated() #
EventRoot<EventArgs> get updated => _updatedEventHandle;
void validateNotDisposed() #
void validateNotDisposed() { assert(!_disposed); }