[Web] Migrate to get and set API [1/2]

src/web/detectors/RotationGestureDetector.ts

@@ -10,23 +10,19 @@ export interface RotationGestureListener {
 export default class RotationGestureDetector
   implements RotationGestureListener
 {
+  private _currentTime = 0;
+  private _previousTime = 0;
+  private _previousAngle = 0;
+  private _rotation = 0;
+  private _anchorX = 0;
+  private _anchorY = 0;
+  private _inProgress = false;
+  private _keyPointers: number[] = [NaN, NaN];
+
   onRotationBegin: (detector: RotationGestureDetector) => boolean;
   onRotation: (detector: RotationGestureDetector) => boolean;
   onRotationEnd: (detector: RotationGestureDetector) => void;
 
-  private currentTime = 0;
-  private previousTime = 0;
-
-  private previousAngle = 0;
-  private rotation = 0;
-
-  private anchorX = 0;
-  private anchorY = 0;
-
-  private isInProgress = false;
-
-  private keyPointers: number[] = [NaN, NaN];
-
   constructor(callbacks: RotationGestureListener) {
     this.onRotationBegin = callbacks.onRotationBegin;
     this.onRotation = callbacks.onRotation;
@@ -71,11 +67,11 @@ export default class RotationGestureDetector
   }
 
   private finish(): void {
-    if (!this.isInProgress) {
+    if (!this.inProgress) {
       return;
     }
 
-    this.isInProgress = false;
+    this.inProgress = false;
     this.keyPointers = [NaN, NaN];
     this.onRotationEnd(this);
   }
@@ -94,14 +90,14 @@ export default class RotationGestureDetector
   public onTouchEvent(event: AdaptedEvent, tracker: PointerTracker): boolean {
     switch (event.eventType) {
       case EventTypes.DOWN:
-        this.isInProgress = false;
+        this.inProgress = false;
         break;
 
       case EventTypes.ADDITIONAL_POINTER_DOWN:
-        if (this.isInProgress) {
+        if (this.inProgress) {
           break;
         }
-        this.isInProgress = true;
+        this.inProgress = true;
 
         this.previousTime = event.time;
         this.previousAngle = NaN;
@@ -113,7 +109,7 @@ export default class RotationGestureDetector
         break;
 
       case EventTypes.MOVE:
-        if (!this.isInProgress) {
+        if (!this.inProgress) {
           break;
         }
 
@@ -123,7 +119,7 @@ export default class RotationGestureDetector
         break;
 
       case EventTypes.ADDITIONAL_POINTER_UP:
-        if (!this.isInProgress) {
+        if (!this.inProgress) {
           break;
         }
 
@@ -134,7 +130,7 @@ export default class RotationGestureDetector
         break;
 
       case EventTypes.UP:
-        if (this.isInProgress) {
+        if (this.inProgress) {
           this.finish();
         }
         break;
@@ -143,24 +139,68 @@ export default class RotationGestureDetector
     return true;
   }
 
-  public getTimeDelta(): number {
-    return this.currentTime + this.previousTime;
+  public reset(): void {
+    this.keyPointers = [NaN, NaN];
+    this.inProgress = false;
   }
 
-  public getAnchorX(): number {
-    return this.anchorX;
+  public get currentTime() {
+    return this._currentTime;
+  }
+  public set currentTime(time: number) {
+    this._currentTime = time;
   }
 
-  public getAnchorY(): number {
-    return this.anchorY;
+  public get previousTime() {
+    return this._previousTime;
+  }
+  public set previousTime(time: number) {
+    this._previousTime = time;
   }
 
-  public getRotation(): number {
-    return this.rotation;
+  public get previousAngle() {
+    return this._previousAngle;
+  }
+  public set previousAngle(angle: number) {
+    this._previousAngle = angle;
   }
 
-  public reset(): void {
-    this.keyPointers = [NaN, NaN];
-    this.isInProgress = false;
+  public get rotation() {
+    return this._rotation;
+  }
+  public set rotation(angle: number) {
+    this._rotation = angle;
+  }
+
+  public get anchorX() {
+    return this._anchorX;
+  }
+  public set anchorX(value: number) {
+    this._anchorX = value;
+  }
+
+  public get anchorY() {
+    return this._anchorY;
+  }
+  public set anchorY(value: number) {
+    this._anchorY = value;
+  }
+
+  public get inProgress() {
+    return this._inProgress;
+  }
+  public set inProgress(inProgress: boolean) {
+    this._inProgress = inProgress;
+  }
+
+  public get keyPointers() {
+    return this._keyPointers;
+  }
+  public set keyPointers(pointers: number[]) {
+    this._keyPointers = pointers;
+  }
+
+  public get timeDelta() {
+    return this.currentTime + this.previousTime;
   }
 }

src/web/detectors/ScaleGestureDetector.ts

@@ -10,32 +10,33 @@ export interface ScaleGestureListener {
 }
 
 export default class ScaleGestureDetector implements ScaleGestureListener {
-  public onScaleBegin: (detector: ScaleGestureDetector) => boolean;
-  public onScale: (detector: ScaleGestureDetector) => boolean;
-  public onScaleEnd: (detector: ScaleGestureDetector) => void;
+  private _focusX!: number;
+  private _focusY!: number;
+  private _currentSpan!: number;
+  private _prevSpan!: number;
+  private _initialSpan!: number;
+  private _currentTime!: number;
+  private _prevTime!: number;
+  private _inProgress = false;
+  private _spanSlop: number;
+  private _minSpan: number;
+  private _pointerTracker: PointerTracker;
 
-  private focusX!: number;
-  private focusY!: number;
-
-  private currentSpan!: number;
-  private prevSpan!: number;
-  private initialSpan!: number;
-
-  private currentTime!: number;
-  private prevTime!: number;
-
-  private inProgress = false;
-
-  private spanSlop: number;
-  private minSpan: number;
+  onScaleBegin: (detector: ScaleGestureDetector) => boolean;
+  onScale: (detector: ScaleGestureDetector) => boolean;
+  onScaleEnd: (detector: ScaleGestureDetector) => void;
 
-  public constructor(callbacks: ScaleGestureListener) {
+  public constructor(
+    callbacks: ScaleGestureListener,
+    pointerTracker: PointerTracker
+  ) {
     this.onScaleBegin = callbacks.onScaleBegin;
     this.onScale = callbacks.onScale;
     this.onScaleEnd = callbacks.onScaleEnd;
 
-    this.spanSlop = DEFAULT_TOUCH_SLOP * 2;
-    this.minSpan = 0;
+    this._spanSlop = DEFAULT_TOUCH_SLOP * 2;
+    this._minSpan = 0;
+    this._pointerTracker = pointerTracker;
   }
 
   public onTouchEvent(event: AdaptedEvent, tracker: PointerTracker): boolean {
@@ -145,24 +146,89 @@ export default class ScaleGestureDetector implements ScaleGestureListener {
     return true;
   }
 
-  public getCurrentSpan(): number {
-    return this.currentSpan;
+  public get focusX() {
+    return this._focusX;
+  }
+  public set focusX(value: number) {
+    this._focusX = value;
+  }
+
+  public get focusY() {
+    return this._focusY;
+  }
+  public set focusY(value: number) {
+    this._focusY = value;
+  }
+
+  public get currentSpan() {
+    return this._currentSpan;
+  }
+  public set currentSpan(value: number) {
+    this._currentSpan = value;
+  }
+
+  public get prevSpan() {
+    return this._prevSpan;
+  }
+  public set prevSpan(value: number) {
+    this._prevSpan = value;
+  }
+
+  public get initialSpan() {
+    return this._initialSpan;
+  }
+  public set initialSpan(value: number) {
+    this._initialSpan = value;
   }
 
-  public getFocusX(): number {
-    return this.focusX;
+  public get currentTime() {
+    return this._currentTime;
+  }
+  public set currentTime(time: number) {
+    this._currentTime = time;
   }
 
-  public getFocusY(): number {
-    return this.focusY;
+  public get prevTime() {
+    return this._prevTime;
+  }
+  public set prevTime(time: number) {
+    this._prevTime = time;
+  }
+
+  public get inProgress() {
+    return this._inProgress;
+  }
+  public set inProgress(inProgress: boolean) {
+    this._inProgress = inProgress;
+  }
+
+  public get spanSlop() {
+    return this._spanSlop;
+  }
+  public set spanSlop(value: number) {
+    this._spanSlop = value;
+  }
+
+  public get minSpan() {
+    return this._minSpan;
+  }
+  public set minSpan(value: number) {
+    this._minSpan = value;
+  }
+
+  public get pointerTracker() {
+    return this._pointerTracker;
+  }
+  public set pointerTracker(pointerTracker: PointerTracker) {
+    this._pointerTracker = pointerTracker;
   }
 
-  public getTimeDelta(): number {
+  public get timeDelta(): number {
     return this.currentTime - this.prevTime;
   }
 
-  public getScaleFactor(numOfPointers: number): number {
-    if (numOfPointers < 2) {
+  public get scaleFactor() {
+    if (this.pointerTracker.getTrackedPointersCount() < 2) {
       return 1;
     }