gameforge - v0.1.12
    Preparing search index...

    Class EventBoundary

    Event boundaries are "barriers" where events coming from an upstream scene are modified before downstream propagation.

    The PIXI.EventSystem#rootBoundary rootBoundary handles events coming from the <canvas />. PIXI.EventSystem handles the normalization from native Events into PIXI.FederatedEvent FederatedEvents. The rootBoundary then does the hit-testing and event dispatch for the upstream normalized event.

    An additional event boundary may be desired within an application's scene graph. For example, if a portion of the scene is is flat with many children at one level - a spatial hash maybe needed to accelerate hit testing. In this scenario, the container can be detached from the scene and glued using a custom event boundary.

    import { Container } from '@pixi/display';
    import { EventBoundary } from '@pixi/events';
    import { SpatialHash } from 'pixi-spatial-hash';

    class HashedHitTestingEventBoundary
    {
        private spatialHash: SpatialHash;

        constructor(scene: Container, spatialHash: SpatialHash)
        {
            super(scene);
            this.spatialHash = spatialHash;
        }

        hitTestRecursive(...)
        {
            // TODO: If target === this.rootTarget, then use spatial hash to get a
            // list of possible children that match the given (x,y) coordinates.
        }
    }

    class VastScene extends DisplayObject
    {
        protected eventBoundary: EventBoundary;
        protected scene: Container;
        protected spatialHash: SpatialHash;

        constructor()
        {
            this.scene = new Container();
            this.spatialHash = new SpatialHash();
            this.eventBoundary = new HashedHitTestingEventBoundary(this.scene, this.spatialHash);

            // Populate this.scene with a ton of children, while updating this.spatialHash
        }
    }

    PIXI

    Index

    Constructors

    constructor

    Properties

    cursor dispatch enableGlobalMoveEvents eventPool mappingState mappingTable moveOnAll rootTarget

    Methods

    addEventMapping all allocateEvent clonePointerEvent copyData copyMouseData copyPointerData copyWheelData createPointerEvent createWheelEvent dispatchEvent findMountedTarget freeEvent hitPruneFn hitTest hitTestFn hitTestMoveRecursive hitTestRecursive mapEvent mapPointerDown mapPointerMove mapPointerOut mapPointerOver mapPointerUp mapPointerUpOutside mapWheel notifyTarget propagate propagationPath trackingData

    Constructors

    Properties

    cursor: string

    The cursor preferred by the event targets underneath this boundary.

    dispatch: Pixi.utils.EventEmitter

    Emits events after they were dispatched into the scene graph.

    This can be used for global events listening, regardless of the scene graph being used. It should not be used by interactive libraries for normal use.

    Special events that do not bubble all the way to the root target are not emitted from here, e.g. pointerenter, pointerleave, click.

    enableGlobalMoveEvents: boolean

    Enables the global move events. globalpointermove, globaltouchmove, and globalmousemove

    eventPool: Map<typeof FederatedEvent, FederatedEvent<UIEvent | PixiTouch>[]>

    The event pool maps event constructors to an free pool of instances of those specific events.

    • PIXI.EventBoundary#allocateEvent
    • PIXI.EventBoundary#freeEvent
    mappingState: Record<string, any>

    State object for mapping methods.

    PIXI.EventBoundary#trackingData

    mappingTable: Record<
        string,
        { fn: (e: FederatedEvent) => void; priority: number }[],
    >

    Maps event types to forwarding handles for them.

    PIXI.EventBoundary EventBoundary provides mapping for "pointerdown", "pointermove", "pointerout", "pointerleave", "pointerover", "pointerup", and "pointerupoutside" by default.

    PIXI.EventBoundary#addEventMapping

    moveOnAll: boolean

    This flag would emit pointermove, touchmove, and mousemove events on all DisplayObjects.

    The moveOnAll semantics mirror those of earlier versions of PixiJS. This was disabled in favor of the Pointer Event API's approach.

    rootTarget: DisplayObject

    The root event-target residing below the event boundary.

    All events are dispatched trickling down and bubbling up to this rootTarget.

    Methods

    • Adds an event mapping for the event type handled by fn.

      Event mappings can be used to implement additional or custom events. They take an event coming from the upstream scene (or directly from the PIXI.EventSystem) and dispatch new downstream events generally trickling down and bubbling up to PIXI.EventBoundary.rootTarget this.rootTarget.

      To modify the semantics of existing events, the built-in mapping methods of EventBoundary should be overridden instead.

      Parameters

      • type: string

        The type of upstream event to map.

      • fn: (e: FederatedEvent) => void

        The mapping method. The context of this function must be bound manually, if desired.

      Returns void

    • Emits the event {@code e} to all interactive display objects. The event is propagated in the bubbling phase always.

      This is used in the globalpointermove event.

      Parameters

      Returns void

    • Allocate a specific type of event from PIXI.EventBoundary#eventPool this.eventPool.

      This allocation is constructor-agnostic, as long as it only takes one argument - this event boundary.

      Type Parameters

      Parameters

      • constructor: new (boundary: EventBoundary) => T

        The event's constructor.

      Returns T

    • Clones the event {@code from}, with an optional {@code type} override.

      The event is allocated using PIXI.EventBoundary#allocateEvent this.allocateEvent.

      Parameters

      Returns FederatedPointerEvent

    • Copies base PIXI.FederatedEvent data from {@code from} into {@code to}.

      The following properties are copied:

      • isTrusted
      • srcElement
      • timeStamp
      • type

      Parameters

      Returns void

    • Copies mouse PIXI.FederatedMouseEvent data from {@code from} to {@code to}.

      The following properties are copied:

      • altKey
      • button
      • buttons
      • clientX
      • clientY
      • metaKey
      • movementX
      • movementY
      • pageX
      • pageY
      • x
      • y
      • screen
      • shiftKey
      • global

      Parameters

      Returns void

    • Copies pointer PIXI.FederatedPointerEvent data from {@code from} into {@code to}.

      The following properties are copied:

      • pointerId
      • width
      • height
      • isPrimary
      • pointerType
      • pressure
      • tangentialPressure
      • tiltX
      • tiltY

      Parameters

      Returns void

    • Creates an event whose {@code originalEvent} is {@code from}, with an optional type and target override.

      The event is allocated using PIXI.EventBoundary#allocateEvent this.allocateEvent.

      Parameters

      Returns FederatedPointerEvent

    • Dispatches the given event

      Parameters

      Returns void

    • Finds the most specific event-target in the given propagation path that is still mounted in the scene graph.

      This is used to find the correct pointerup and pointerout target in the case that the original pointerdown or pointerover target was unmounted from the scene graph.

      Parameters

      Returns FederatedEventTarget

      • The most specific event-target still mounted at the same location in the scene graph.

    • Frees the event and puts it back into the event pool.

      It is illegal to reuse the event until it is allocated again, using this.allocateEvent.

      It is also advised that events not allocated from PIXI.EventBoundary#allocateEvent this.allocateEvent not be freed. This is because of the possibility that the same event is freed twice, which can cause it to be allocated twice & result in overwriting.

      Type Parameters

      Parameters

      • event: T

        The event to be freed.

      Returns void

      Error if the event is managed by another event boundary.

    • Checks whether the display object or any of its children cannot pass the hit test at all.

      PIXI.EventBoundary's implementation uses the PIXI.DisplayObject.hitArea hitArea and PIXI.DisplayObject._mask for pruning.

      Parameters

      Returns boolean

    • Finds the DisplayObject that is the target of a event at the given coordinates.

      The passed (x,y) coordinates are in the world space above this event boundary.

      Parameters

      • x: number
      • y: number

      Returns DisplayObject

    • Checks whether the display object passes hit testing for the given location.

      Parameters

      Returns boolean

      • Whether displayObject passes hit testing for location.

    • Recursive implementation for PIXI.EventBoundary.hitTest hitTest.

      Parameters

      • currentTarget: DisplayObject

        The DisplayObject that is to be hit tested.

      • eventMode: EventMode

        The event mode for the currentTarget or one of its parents.

      • location: Point

        The location that is being tested for overlap.

      • testFn: (object: DisplayObject, pt: Point) => boolean

        Callback that determines whether the target passes hit testing. This callback can assume that pruneFn failed to prune the display object.

      • OptionalpruneFn: (object: DisplayObject, pt: Point) => boolean

        Callback that determiness whether the target and all of its children cannot pass the hit test. It is used as a preliminary optimization to prune entire subtrees of the scene graph.

      Returns DisplayObject[]

      An array holding the hit testing target and all its ancestors in order. The first element is the target itself and the last is PIXI.EventBoundary.rootTarget rootTarget. This is the opposite order w.r.t. the propagation path. If no hit testing target is found, null is returned.

    • Maps the given upstream event through the event boundary and propagates it downstream.

      Parameters

      Returns void

    • Maps the upstream pointerdown events to a downstream pointerdown event.

      touchstart, rightdown, mousedown events are also dispatched for specific pointer types.

      Parameters

      Returns void

    • Maps the upstream pointermove to downstream pointerout, pointerover, and pointermove events, in that order.

      The tracking data for the specific pointer has an updated overTarget. mouseout, mouseover, mousemove, and touchmove events are fired as well for specific pointer types.

      Parameters

      Returns void

    • Maps the upstream pointerout to downstream pointerout, pointerleave events, in that order.

      The tracking data for the specific pointer is cleared of a overTarget.

      Parameters

      Returns void

    • Maps the upstream pointerover to downstream pointerover and pointerenter events, in that order.

      The tracking data for the specific pointer gets a new overTarget.

      Parameters

      Returns void

    • Maps the upstream pointerup event to downstream pointerup, pointerupoutside, and click/rightclick/pointertap events, in that order.

      The pointerupoutside event bubbles from the original pointerdown target to the most specific ancestor of the pointerdown and pointerup targets, which is also the click event's target. touchend, rightup, mouseup, touchendoutside, rightupoutside, mouseupoutside, and tap are fired as well for specific pointer types.

      Parameters

      Returns void

    • Maps the upstream pointerupoutside event to a downstream pointerupoutside event, bubbling from the original pointerdown target to rootTarget.

      (The most specific ancestor of the pointerdown event and the pointerup event must the {@link PIXI.EventBoundary}'s root because the pointerup` event occurred outside of the boundary.)

      touchendoutside, mouseupoutside, and rightupoutside events are fired as well for specific pointer types. The tracking data for the specific pointer is cleared of a pressTarget.

      Parameters

      Returns void

    • Maps the upstream wheel event to a downstream wheel event.

      Parameters

      Returns void

    • Notify all the listeners to the event's currentTarget.

      If the currentTarget contains the property on<type>, then it is called here, simulating the behavior from version 6.x and prior.

      Parameters

      Returns void

    • Propagate the passed event from from PIXI.EventBoundary.rootTarget this.rootTarget to its target {@code e.target}.

      Parameters

      Returns void

    • Parameters

      • id: number

        The pointer ID.

      Returns TrackingData

      The tracking data stored for the given pointer. If no data exists, a blank state will be created.

    Settings

    Member Visibility

    On This Page

    Root event boundaryAdditional event boundaries
    Constructors
    Properties
    Methods