Source: TextAnnInfo.js

/**
 * @content 用于对多点的几何功能组件
 * @author  2019-09-09
 */
import { NativeModules } from 'react-native';

let TAI = NativeModules.JSTextAnnInfo;

import AnnInfo from './AnnInfo.js';

/**
 * @class TextAnnInfo
 */
export default class TextAnnInfo extends AnnInfo {
  constructor() {
    super();
    Object.defineProperty(this, '_MGTextAnnInfoId', {
      get: function() {
        return this._MGGeomInfoId;
      },
      set: function(_MGTextAnnInfoId) {
        this._MGGeomInfoId = _MGTextAnnInfoId;
      },
    });
  }

  /**
   * 构造一个新的 TextAnnInfo 对象
   * @memberOf TextAnnInfo
   * @return {Promise<TextAnnInfo>}
   */
  async createObj() {
    try {
      var { TextAnnInfoId } = await TAI.createObj();
      var textAnnInfo = new TextAnnInfo();
      textAnnInfo._MGTextAnnInfoId = TextAnnInfoId;
      return textAnnInfo;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本显示高度
   * @memberOf TextAnnInfo
   * @return {Promise} 高度值
   *
   */
  async getHeight() {
    try {
      return await TAI.getHeight(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本显示高度
   * @memberOf TextAnnInfo
   * @param newVal 高度值
   * @return {Promise<void>}
   */
  async setHeight(newVal) {
    try {
      await TAI.setHeight(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本显示宽度
   * @memberOf TextAnnInfo
   * @return {Promise}宽度值
   */
  async getWidth() {
    try {
      return await TAI.getWidth(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本显示宽度
   * @memberOf TextAnnInfo
   * @param newVal 宽度值
   * @return {Promise<void>}
   */
  async setWidth(newVal) {
    try {
      await TAI.setWidth(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本显示间隔
   * @memberOf TextAnnInfo
   * @return {Promise}间隔值
   */
  async getSpace() {
    try {
      return await TAI.getSpace(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本显示间隔
   * @memberOf TextAnnInfo
   * @param newVal 间隔值
   * @return {Promise<void>}
   */
  async setSpace(newVal) {
    try {
      await TAI.setSpace(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本显示字角度
   * @memberOf TextAnnInfo
   * @return {Promise}字角度值
   */
  async getFontAngle() {
    try {
      return await TAI.getFontAngle(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本显示字角度
   * @memberOf TextAnnInfo
   * @param newVal 字角度值
   * @return {Promise<void>}
   */
  async setFontAngle(newVal) {
    try {
      await TAI.setFontAngle(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本显示字串角度
   * @memberOf TextAnnInfo
   * @return {Promise}字串角度值
   */
  async getAngle() {
    try {
      return await TAI.getAngle(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本显示字串角度
   * @memberOf TextAnnInfo
   * @param newVal 字串角度值
   * @return {Promise<void>}
   */
  async setAngle(newVal) {
    try {
      await TAI.setAngle(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本中文字体
   * @memberOf TextAnnInfo
   * @return {Promise}中文字体
   */
  async getIfnt() {
    try {
      return await TAI.getIfnt(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本中文字体
   * @memberOf TextAnnInfo
   * @param newVal 中文字体
   * @return {Promise<void>}
   */
  async setIfnt(newVal) {
    try {
      await TAI.setIfnt(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本西文字体
   * @memberOf TextAnnInfo
   * @return {Promise}西文字体
   */
  async getChnt() {
    try {
      return await TAI.getChnt(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本西文字体
   * @memberOf TextAnnInfo
   * @param newVal 西文字体
   * @return {Promise<void>}
   */
  async setChnt(newVal) {
    try {
      await TAI.setChnt(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本的字形
   * @memberOf TextAnnInfo
   * @return {Promise}字形
   */
  async getIfnx() {
    try {
      return await TAI.getIfnx(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本的字形
   * @memberOf TextAnnInfo
   * @param newVal 字形
   * @return {Promise<void>}
   */
  async setIfnx(newVal) {
    try {
      await TAI.setIfnx(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本显示水平或垂直排列
   * @memberOf TextAnnInfo
   * @return {Promise}水平排列返回true，垂直排列返回false
   */
  async getIsHzpl() {
    try {
      return await TAI.getIsHzpl(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本水平或垂直排列
   * @memberOf TextAnnInfo
   * @param newVal 水平排列传true，垂直排列传false
   * @return {Promise<void>}
   */
  async setIsHzpl(newVal) {
    try {
      await TAI.setIsHzpl(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本显示颜色
   * @memberOf TextAnnInfo
   * @return {Promise<Number>}颜色号
   */
  async getColor() {
    try {
      let color = await TAI.getColor(this._MGTextAnnInfoId);
      return color;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本显示颜色
   * @memberOf TextAnnInfo
   * @param {Number}  color 颜色号
   * @return {Promise<void>}
   */
  async setColor(color) {
    try {
      await TAI.setColor(this._MGTextAnnInfoId, color);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本覆盖方式,表示透明/覆盖
   * @memberOf TextAnnInfo
   * @return {Promise}透明/覆盖
   */
  async getIsOvprnt() {
    try {
      return await TAI.getIsOvprnt(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本覆盖方式,表示透明/覆盖
   * @memberOf TextAnnInfo
   * @param newVal 透明/覆盖
   * @return {Promise<void>}
   */
  async setIsOvprnt(newVal) {
    try {
      await TAI.setIsOvprnt(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本自动压背景颜色标志
   * @memberOf TextAnnInfo
   * @return {Promise}自动压背景颜色返回true，否则返回false
   */
  async getIsFilled() {
    try {
      return await TAI.getIsFilled(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本自动压背景颜色标志
   * @memberOf TextAnnInfo
   * @param newVal 自动压背景设置true，否则返回false
   * @return {Promise<void>}
   */
  async setIsFilled(newVal) {
    try {
      await TAI.setIsFilled(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本显示范围扩展
   * @memberOf TextAnnInfo
   * @return {Promise}扩展值
   */
  async getBackExp() {
    try {
      return await TAI.getBackExp(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本显示范围扩展
   * @memberOf TextAnnInfo
   * @param newVal 扩展值
   * @return {Promise<void>}
   */
  async setBackExp(newVal) {
    try {
      await TAI.setBackExp(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本覆盖的背景颜色
   * @memberOf TextAnnInfo
   * @return {Promise<Number>}颜色号
   */
  async getBackClr() {
    try {
      let color = await TAI.getBackClr(this._MGTextAnnInfoId);
      return color;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本覆盖的背景颜色
   * @memberOf TextAnnInfo
   * @param {Number}  color 颜色号
   * @return {Promise<void>}
   */
  async setBackClr(color) {
    try {
      await TAI.setBackClr(this._MGTextAnnInfoId, color);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本显示x方向的偏移
   * @memberOf TextAnnInfo
   * @return {Promise}偏移值
   */
  async getOffsetX() {
    try {
      return await TAI.getOffsetX(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本显示x方向的偏移
   * @memberOf TextAnnInfo
   * @param newVal 偏移值
   * @return {Promise<void>}
   */
  async setOffsetX(newVal) {
    try {
      await TAI.setOffsetX(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取文本显示y方向的偏移
   * @memberOf TextAnnInfo
   * @return {Promise}偏移值
   */
  async getOffsetY() {
    try {
      return await TAI.getOffsetY(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置文本显示y方向的偏移
   * @memberOf TextAnnInfo
   * @param newVal 偏移值
   * @return {Promise<void>}
   */
  async setOffsetY(newVal) {
    try {
      await TAI.setOffsetY(this._MGTextAnnInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 几何注记类类型
   * @memberOf TextAnnInfo
   * @return {Promise}几何注记类类型
   */
  async getAnnType() {
    try {
      return await TAI.getAnnType(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取几何类型
   * @memberOf TextAnnInfo
   * @return {Promise}  几何类型
   */
  async getGeomType() {
    try {
      return await TAI.getGeomType(this._MGTextAnnInfoId);
    } catch (e) {
      console.error(e);
    }
  }
}