Source: SnappingOption.js

/*
 * @Description: In User Settings Edit
 * @Author: xiaoying
 * @Date: 2019-09-10 19:19:22
 * @LastEditTime: 2019-09-10 19:41:05
 * @LastEditors: mayuanye
 */
import { NativeModules } from 'react-native';
let SO = NativeModules.JSSnappingOption;

/**
 * @class SnappingOption
 * @description 捕捉选项
 */
export default class SnappingOption {
  /**
   * 构造一个新的SnappingOption对象
   *
   * @memberof SnappingOption
   * @returns {Promise<SnappingOption>}
   */
  async createObj() {
    try {
      var { SnappingOptionId } = await SO.createObj();
      var snappingOption = new SnappingOption();
      snappingOption._MGSnappingOptionId = SnappingOptionId;
      return snappingOption;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取容差（像素单位）
   * @memberof SnappingOption
   * @returns {Number} 容差 （int类型的Number）
   */
  async getPixelsTolerance() {
    try {
      let result = await SO.getPixelsTolerance(this._MGSnappingOptionId);
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置容差（像素单位）
   * @memberof SnappingOption
   * @param {Number} pixelsTolerance 容差 （int类型的Number）
   * @returns {Promise<Void>}
   */
  async setPixelsTolerance(pixelsTolerance) {
    try {
      await SO.setPixelsTolerance(this._MGSnappingOptionId, pixelsTolerance);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取是否自动捕捉顶点
   * @memberof SnappingOption
   * @returns {boolean} 是否自动捕捉顶点
   */
  async isSnappingVertex() {
    try {
      let result = await SO.isSnappingVertex(this._MGSnappingOptionId);
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置是否自动捕捉顶点
   * @memberof SnappingOption
   * @param {boolean} isSnappingVertex 是否自动捕捉顶点
   * @returns {Promise<Void>}
   */
  async setSnappingVertex(isSnappingVertex) {
    try {
      await SO.setSnappingVertex(this._MGSnappingOptionId, isSnappingVertex);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取是否自动捕捉中点
   * @memberof SnappingOption
   * @returns {boolean}
   */
  async isSnappingMidVertex() {
    try {
      let result = await SO.isSnappingMidVertex(this._MGSnappingOptionId);
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置是否自动捕捉中点
   * @memberof SnappingOption
   * @param {boolean} isSnappingMidVertex
   * @returns {Promise<Void>}
   */
  async setSnappingMidVertex(isSnappingMidVertex) {
    try {
      await SO.setSnappingMidVertex(
        this._MGSnappingOptionId,
        isSnappingMidVertex
      );
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取是否自动捕捉垂点
   * @memberof SnappingOption
   * @returns {boolean}
   */
  async isSnappingPedal() {
    try {
      let result = await SO.isSnappingPedal(this._MGSnappingOptionId);
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置是否自动捕捉垂点
   * @memberof SnappingOption
   * @param {boolean} isSnappingPedal 是否自动捕捉垂点
   * @returns {Promise<Void>}
   */
  async setSnappingPedal(isSnappingPedal) {
    try {
      await SO.setSnappingPedal(this._MGSnappingOptionId, isSnappingPedal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取是否自动捕捉普通交点
   * @memberof SnappingOption
   * @returns {boolean}
   */
  async isSnappingNormalIntersection() {
    try {
      let result = await SO.isSnappingNormalIntersection(
        this._MGSnappingOptionId
      );
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置是否自动捕捉普通交点
   * @memberof SnappingOption
   * @param {boolean} isSnappingNormalIntersection 是否自动捕捉普通交点
   * @returns {Promise<Void>}
   */
  async setSnappingNormalIntersection(isSnappingNormalIntersection) {
    try {
      await SO.setSnappingNormalIntersection(
        this._MGSnappingOptionId,
        isSnappingNormalIntersection
      );
    } catch (e) {
      console.error(e);
    }
  }

  /**
   *  获取是否自动捕捉水平交点
   * @memberof SnappingOption
   * @returns {boolean}
   */
  async isSnappingHorizontalIntersection() {
    try {
      let result = await SO.isSnappingHorizontalIntersection(
        this._MGSnappingOptionId
      );
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置是否自动捕捉水平交点
   * @memberof SnappingOption
   * @param {boolean} isSnappingHorizontalIntersection 是否自动捕捉水平交点
   * @returns {Promise<Void>}
   */
  async setSnappingHorizontalIntersection(isSnappingHorizontalIntersection) {
    try {
      await SO.setSnappingHorizontalIntersection(
        this._MGSnappingOptionId,
        isSnappingHorizontalIntersection
      );
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取是否自动捕捉垂直交点
   * @memberof SnappingOption
   * @returns {boolean}
   */
  async isSnappingVerticalIntersection() {
    try {
      let result = await SO.isSnappingVerticalIntersection(
        this._MGSnappingOptionId
      );
      return result;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置是否自动捕捉垂直交点
   * @memberof SnappingOption
   * @param {boolean} isSnappingVerticalIntersection 是否自动捕捉垂直交点
   * @returns {Promise<Void>}
   */
  async setSnappingVerticalIntersection(isSnappingVerticalIntersection) {
    try {
      await SO.setSnappingVerticalIntersection(
        this._MGSnappingOptionId,
        isSnappingVerticalIntersection
      );
    } catch (e) {
      console.error(e);
    }
  }
}