# Source: LinInfo.js

    /**
     * @content 线图形信息功能组件
     * @author  2019-09-12
     */
    import { NativeModules } from 'react-native';

    let LI = NativeModules.JSLinInfo;

    import GeomInfo from './GeomInfo.js';

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

      /**
       * 构造一个新的 LinInfo 对象
       * @memberOf LinInfo
       * @return {Promise<LinInfo>}
       */
      async createObj() {
        try {
          var { LinInfoId } = await LI.createObj();
          var linInfo = new LinInfo();
          linInfo._MGLinInfoId = LinInfoId;
          return linInfo;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 构造一个新的 LinInfo 对象
       * @memberOf LinInfo
       * @param adjustFlg 线型调整方法
    	 * @param headType 线头类型
    	 * @param joinType 拐角类型
    	 * @param libId 库编号
    	 * @param linStyId 线型号
    	 * @param makeMethod 线型生成方法
    	 * @param outClr1 可变颜色1
    	 * @param outClr2 可变颜色2
    	 * @param outClr3 可变颜色3
    	 * @param outPenW1 外部笔宽1
    	 * @param outPenW2 外部笔宽2
    	 * @param outPenW3 外部笔宽3
    	 * @param ovprnt 覆盖方式
    	 * @param xScale X系数
    	 * @param yScale Y系数
       * @return {Promise<LinInfo>}
       */
      async createObjByParam(adjustFlg, headType, joinType, libId, linStyId, makeMethod, outClr1, outClr2, outClr3,
        outPenW1, outPenW2, outPenW3, ovprnt, xScale, yScale) {
        try {
          var { LinInfoId } = await LI.createObjByParam(adjustFlg, headType, joinType, libId, linStyId, makeMethod, outClr1, outClr2, outClr3,
            outPenW1, outPenW2, outPenW3, ovprnt, xScale, yScale);
          var linInfo = new LinInfo();
          linInfo._MGLinInfoId = LinInfoId;
          return linInfo;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取库编号
       * @memberOf LinInfo
       * @return {Promise}库编号
       */
      async getLibID() {
        try {
          return await LI.getLibID(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置库编号
       * @memberOf LinInfo
       * @param newVal 库编号
       * @return {Promise<void>}
       */
      async setLibID(newVal) {
        try {
          await LI.setLibID(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取覆盖方式
       * @memberOf LinInfo
       * @return {Promise}覆盖方式
       */
      async getOvprnt() {
        try {
          return await LI.getOvprnt(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取线型号
       * @memberOf LinInfo
       * @return {Promise}线型号
       */
      async getLinStyID() {
        try {
          return await LI.getLinStyID(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置线型号
       * @memberOf LinInfo
       * @param newVal 线型号
       * @return {Promise<void>}
       */
      async setLinStyID(newVal) {
        try {
          await LI.setLinStyID(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取外部笔宽1
       * @memberOf LinInfo
       * @return {Promise}外部笔宽1
       */
      async getOutPenW1() {
        try {
          return await LI.getOutPenW1(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置外部笔宽1
       * @memberOf LinInfo
       * @param newVal 外部笔宽1
       * @return {Promise<void>}
       */
      async setOutPenW1(newVal) {
        try {
          await LI.setOutPenW1(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取外部笔宽2
       * @memberOf LinInfo
       * @return {Promise}外部笔宽2
       */
      async getOutPenW2() {
        try {
          return await LI.getOutPenW2(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置外部笔宽2
       * @memberOf LinInfo
       * @param newVal 外部笔宽2
       * @return {Promise<void>}
       */
      async setOutPenW2(newVal) {
        try {
          await LI.setOutPenW2(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取外部笔宽3
       * @memberOf LinInfo
       * @return {Promise}外部笔宽3
       */
      async getOutPenW3() {
        try {
          return await LI.getOutPenW3(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置外部笔宽3
       * @memberOf LinInfo
       * @param newVal 外部笔宽3
       * @return {Promise<void>}
       */
      async setOutPenW3(newVal) {
        try {
          await LI.setOutPenW3(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取可变颜色1
       * @memberOf LinInfo
       * @return {Number}可变颜色1
       */
      async getOutClr1() {
        try {
          let color = await LI.getOutClr1(this._MGLinInfoId);
          return color;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置可变颜色1
       * @memberOf LinInfo
       * @param {Number} color 可变颜色1
       * @return {Promise<void>}
       */
      async setOutClr1(color) {
        try {
          await LI.setOutClr1(this._MGLinInfoId, color);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取可变颜色2
       * @memberOf LinInfo
       * @return {Number}可变颜色2
       */
      async getOutClr2() {
        try {
          let color = await LI.getOutClr2(this._MGLinInfoId);
          return color;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置可变颜色2
       * @memberOf LinInfo
       * @param {Number} color  可变颜色2
       * @return {Promise<void>}
       */
      async setOutClr2(color) {
        try {
          await LI.setOutClr2(this._MGLinInfoId, color);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取可变颜色3
       * @memberOf LinInfo
       * @return {Number}可变颜色3
       */
      async getOutClr3() {
        try {
          let color= await LI.getOutClr3(this._MGLinInfoId);
          return color;
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置可变颜色3
       * @memberOf LinInfo
       * @param {Number} color  可变颜色3
       * @return {Promise<void>}
       */
      async setOutClr3(color) {
        try {
          await LI.setOutClr3(this._MGLinInfoId, color);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取线头类型
       * @memberOf LinInfo
       * @return {Promise}线头类型
       */
      async getHeadType() {
        try {
          return await LI.getHeadType(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置线头类型
       * @memberOf LinInfo
       * @param newVal 线头类型
       * @return {Promise<void>}
       */
      async setHeadType(newVal) {
        try {
          await LI.setHeadType(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取拐角类型
       * @memberOf LinInfo
       * @return {Promise}拐角类型
       */
      async getJoinType() {
        try {
          return await LI.getJoinType(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置拐角类型
       * @memberOf LinInfo
       * @param newVal 拐角类型
       * @return {Promise<void>}
       */
      async setJoinType(newVal) {
        try {
          await LI.setJoinType(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取线型调整方法
       * @memberOf LinInfo
       * @return {Promise}线型调整方法
       */
      async getAdjustFlg() {
        try {
          return await LI.getAdjustFlg(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置线型调整方法
       * @memberOf LinInfo
       * @param newVal 线型调整方法
       * @return {Promise<void>}
       */
      async setAdjustFlg(newVal) {
        try {
          await LI.setAdjustFlg(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取线型生成方法
       * @memberOf LinInfo
       * @return {Promise}线型生成方法
       */
      async getMakeMethod() {
        try {
          return await LI.getMakeMethod(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置线型生成方法
       * @memberOf LinInfo
       * @param newVal 线型生成方法
       * @return {Promise<void>}
       */
      async setMakeMethod(newVal) {
        try {
          await LI.setMakeMethod(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取X系数
       * @memberOf LinInfo
       * @return {Promise}X系数
       */
      async getXScale() {
        try {
          return await LI.getXScale(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置X系数
       * @memberOf LinInfo
       * @param newVal X系数
       * @return {Promise<void>}
       */
      async setXScale(newVal) {
        try {
          await LI.setXScale(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 获取Y系数
       * @memberOf LinInfo
       * @return {Promise}Y系数
       */
      async getYScale() {
        try {
          return await LI.getYScale(this._MGLinInfoId);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 设置Y系数
       * @memberOf LinInfo
       * @param newVal Y系数
       * @return {Promise<void>}
       */
      async setYScale(newVal) {
        try {
          await LI.setYScale(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

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

      /**
       * 设置覆盖方式
       * @memberOf PntInfo
       * @param newVal 覆盖方式
       * @return {Promise<void>}
       */
      async setOvprnt(newVal) {
        try {
          await LI.setOvprnt(this._MGLinInfoId, newVal);
        } catch (e) {
          console.error(e);
        }
      }

      /**
       * 克隆几何图形信息
       * @memberOf LinInfo
       * @return {Promise<GeomInfo>} 几何图形信息
       */
      async Clone() {
        try {
          let { GeomInfoId } = await LI.Clone(this._MGLinInfoId);
          var geomInfo = new GeomInfo();
          geomInfo._MGGeomInfoId = GeomInfoId;
          return geomInfo;
        } catch (e) {
          console.error(e);
        }
      }
    }