igeom/src/app/components/intersection-component/drawers/intersection-drawer.js

import { PointDrawer } from "../../point-component/drawers/point-drawer";
import { ELEMENTS_CLASS } from "../../../core/enums/elements-class-enum";
import { Drawer } from "../../../core/drawers/drawer";
import { app as App } from "../../../app";
import { objects } from "../../../core/application/objects";
import { DrawerAggregator } from "../../../core/drawers/drawer-aggregator";
import { intersectionService } from "../services/intersection-service";

export class IntersectionDrawer extends Drawer {
  static FIRST_OBJECT_STATE() {
    return "FIRST_OBJECT";
  }
  static SECOND_OBJECT_STATE() {
    return "SECOND_OBJECTf";
  }
  constructor() {
    super();
    this.aggregatorA;
    this.aggregatorB;
    this.label;
    this.states = [
      IntersectionDrawer.FIRST_OBJECT_STATE,
      IntersectionDrawer.SECOND_OBJECT_STATE
    ];
    this.intersections = [];
    this.pointDrawer = new PointDrawer();
    super.setElementClass(ELEMENTS_CLASS.INTERSECTION_POINT);
  }
  draw(e) {
    if (e != undefined && e.attrs != undefined) {
      this.aggregatorA = this.getObjectAggregatorByGenericObject(e.attrs.genericObject.r);
      this.aggregatorB = this.getObjectAggregatorByGenericObject(e.attrs.genericObject.s);
      this.drawByIntersectionPoints([e.attrs.genericObject]);
      return;
    }
    if (e == undefined || !this.isValidObject(e.target)) return;

    const selectedTool = App.getSelectedTool();
    if (
      selectedTool != undefined &&
      selectedTool.drawer != undefined &&
      selectedTool.drawer.elementClass == ELEMENTS_CLASS.INTERSECTION_POINT
    ) {
      if (
        this.state == undefined ||
        this.state == IntersectionDrawer.FIRST_OBJECT_STATE
      ) {
        this.setFirstObject(e.target);
        this.setState(IntersectionDrawer.SECOND_OBJECT_STATE);
      } else if (this.state == IntersectionDrawer.SECOND_OBJECT_STATE) {
        this.setSecondObject(e.target);
        this.drawPoint();
        this.clear();
      }
    }
  }
  setFirstObject(konvaObject) {
    const aggregator = this.getObjectAggregator(konvaObject);
    this.aggregatorA = aggregator;
  }
  setSecondObject(konvaObject) {
    const aggregator = this.getObjectAggregator(konvaObject);
    this.aggregatorB = aggregator;
  }
  getObjectAggregator(konvaObject) {
    return objects.getByKonvaObject(konvaObject)[0];
  }
  getObjectAggregatorByGenericObject(genericObject) {
    return objects.getByGenericObject(genericObject)[0];
  }
  drawPoint() {
    const intersectionPoints = intersectionService.addIntersections(this.aggregatorA.genericObject.getIntersection(
      this.aggregatorB.genericObject
    ));
    this.drawByIntersectionPoints(intersectionPoints);
  }
  drawByIntersectionPoints(intersectionPoints) {
    for (let index = 0; index < intersectionPoints.length; index++) {
      const intersectionPoint = intersectionPoints[index];
      intersectionPoint.update();
      // if (!intersectionPoint.visible) return;
      const point = PointDrawer.drawPoint(
        intersectionPoint,
        false,
        false,
        true
      );
      const aggregator = new DrawerAggregator(
        this,
        intersectionPoint,
        point.konvaObject,
        ELEMENTS_CLASS.INTERSECTION_POINT
      );
      super.addAggregator(aggregator);
      this.aggregatorB.addAggregator(aggregator);
      this.aggregatorA.addAggregator(aggregator);
    }
  }
  isValidObject(konvaObject) {
    switch (konvaObject.attrs.class) {
      case ELEMENTS_CLASS.LINE_SEGMENT:
        return true;
      case ELEMENTS_CLASS.CIRCUMFERENCE:
        return true;
      default:
        return false;
    }
  }
  update(aggregator, e) {

    aggregator.genericObject.update(aggregator, e);

    if (!aggregator.genericObject.visible || aggregator.genericObject.posX == Number.MAX_SAFE_INTEGER) {
      if (aggregator.visible) {

        aggregator.konvaObject.hide();
        aggregator.aggregators.forEach(a => {
          a.visible = false;
          a.konvaObject.hide();
        });
        this.batchDraw();
      }
      aggregator.visible = false;
      return;
    }
    aggregator.konvaObject.x(aggregator.genericObject.posX);
    aggregator.konvaObject.y(aggregator.genericObject.posY);
    if (!aggregator.visible || aggregator.genericObject.posX == Number.MAX_SAFE_INTEGER) {
      aggregator.genericObject.visible = true;
      aggregator.konvaObject.show();
      aggregator.aggregators.forEach(a => {
        a.visible = true;
        a.konvaObject.show();
      });
      aggregator.visible = true;
    }
    this.batchDraw();
  }
  reset() {
    this.aggregatorA = undefined;
    this.aggregatorB = undefined;
    this.setState(undefined);
  }
}