cad_house/src/CAD/eleAttr.ts

import {AttachCAD} from './core/index'
import Column from './core/architecture/column'
import Door from './core/architecture/door/index'
import Casement from './core/architecture/casement'
import Arch from './core/architecture/linearch'
import WallLine from './core/core/wallline'
import Point from './core/core/point'
import {FurnClass as Furn} from './core/furniture/furn'

import {
  lineDis,
  lineCenter,
  getDisPointLinePoints,
  segmentsIntrFine,
  isContainPoint,
  lineStretch
} from './core/geometry'
import processing from './core/base/processing/index'

function attrAdd(cad, processing) {
  let addCase = processing.addCase
  let addDoor = processing.addDoor
  let addColumn = processing.addColumn
  let addLine = processing.addLine
  let addSlideDoor = processing.addSlideDoor
  let addBayCase = processing.addBayCase
  let addGroundCase = processing.addGroundCase
  let addFurnColumn = processing.addFurnColumn
  let addFurnFlue = processing.addFurnFlue
  let adddDoubleDoor = processing.adddDoubleDoor

  // 添加与宽度相关的属性
  let addWidthAttr = (ele: Column | Door | Casement ) => {
    Object.defineProperties(ele, {
      // 修改宽度
      ewidth: {
        get: () => Number(lineDis({points: ele.linePoints}).toFixed(2)),
        set: (val) => {
          if (val <= 0 || val === ele.ewidth) return;
          let center = lineCenter({points: ele.linePoints})
          let [p1, p2] = getDisPointLinePoints(ele.attachment, center, val / 2)

          if (lineDis({points: [ele.linePoints[0], p1]}) > lineDis({points: [ele.linePoints[0], p2]})) {
            ele.linePoints[0].x = p2.x
            ele.linePoints[0].y = p2.y
            ele.linePoints[1].x = p1.x
            ele.linePoints[1].y = p1.y
          } else {
            ele.linePoints[0].x = p1.x
            ele.linePoints[0].y = p1.y
            ele.linePoints[1].x = p2.x
            ele.linePoints[1].y = p2.y
          }
        }
      },
      // 最大宽度
      maxWidth: {
        get: () => {
          let archs = [ele.attachment] as any
          let p1MinPoints: Array<{dis: number, point: Point}> = []
          let p2MinPoints: Array<{dis: number, point: Point}> = []
          let item = (arch: any, i, j) : {dis: number, point: Point} => {
            let points = arch.linePoints || arch.points
            return {
              dis: lineDis({points: [ele.linePoints[i], points[j]]}), 
              point: points[j]
            }
          }

          archs.forEach(arch => {
            if (arch !== ele) {
              p1MinPoints.push(item(arch, 0, 0))
              p1MinPoints.push(item(arch, 0, 1))
              p2MinPoints.push(item(arch, 1, 0))
              p2MinPoints.push(item(arch, 1, 1))
            }
          })

          p1MinPoints.sort((a, b) => a.dis - b.dis)
          p2MinPoints.sort((a, b) => a.dis - b.dis)
          
          let points = (p1MinPoints[0].dis > p2MinPoints[0].dis ?
            [ele.linePoints[1], p2MinPoints[0].point] :
            [ele.linePoints[0], p1MinPoints[0].point]) as [Point, Point];

          
          return Number((lineDis({points}) * 2 + lineDis({points: ele.linePoints})).toFixed(2))
        }
      },
      minWidth: {
        get: () => 0
      }
    })
  }

  
  // 添加与宽度相关的属性
  let addStartAttr = (ele: Column | Door | Casement ) => {
    Object.defineProperties(ele, {
      // 修改宽度
      estart: {
        get() {
          return ele.start
        },
        set: (val) => {
          if (val) {
            cad.processing.doors.forEach(door => {
              door.ele.start = false
            })
          }
          ele.start = val

          cad.preservation()
        }
      }
    })
  }
  

  // 为柱子添加厚度的属性
  let addTickAttr = (ele: Column) => {
    Object.defineProperties(ele, {
      tick: {
        get: () => Math.max(
          Number(lineDis({points: [ele.points[0], ele.points[3]]}).toFixed(2)),
          Number(lineDis({points: [ele.points[1], ele.points[2]]}).toFixed(2)),
        ),
        set: (val) => {
          if (val <= 0 || val === ele.oldVal) return;
          ele.oldVal = val
          ele.thickness = val
          ele.updatePeripheral()
        }
      },
      maxTick: {
        get() {
          return 10;
          
          let line1 = {points: [ele.points[0], ele.points[3]]} as {points: [Point, Point]}
          let line2 = {points: [ele.points[1], ele.points[2]]} as {points: [Point, Point]}
          let lines = ele.attachment.wallLines
          let j1points = []
          let j2points = []

          for (let i = 0; i < lines.length; i++) {
            if (lines[i] === ele.attachment) continue;

            let point1 = segmentsIntrFine(lines[i], line1)
            let point2 = segmentsIntrFine(lines[i], line2)

            if (point1 && isContainPoint(lines[i], point1 as unknown as Point)) {
              j1points.push(point1)
            }
            if (point2 && isContainPoint(lines[i], point2 as unknown as Point)) {
              j2points.push(point2)
            }
          }

          j1points.sort((a, b) => lineDis({points: [ele.points[0], a]}) - lineDis({points: [ele.points[0], b]}))
          j2points.sort((a, b) => lineDis({points: [ele.points[1], a]}) - lineDis({points: [ele.points[1], b]}))

          let minp1len = 0;
          for(let i = 0; i < j1points.length; i++) {
            if ( isContainPoint({points: [ele.points[0], j1points[i]]}, ele.points[3]) ||
            isContainPoint({points: [ele.points[0], ele.points[3]]}, j1points[i]) ) {
              minp1len = lineDis({points: [ele.points[0], j1points[i]]})
              break;
            }
          }
          let minp2len = 0;
          for(let i = 0; i < j2points.length; i++) {
            if ( isContainPoint({points: [ele.points[1], j2points[i]]}, ele.points[2]) ||
            isContainPoint({points: [ele.points[1], ele.points[2]]}, j2points[i]) ) {
              minp2len = lineDis({points: [ele.points[1], j2points[i]]})
              break;
            }
          }

          let len = !minp1len ? minp2len : 
            !minp2len ? minp1len :
              minp1len < minp2len ? minp1len : minp2len


          return Number((len).toFixed(2)) || 10
        }
      },
      minTick: {
        get: () => 0
      }
    })
  }


  processing.addCase = function(...args) {
    let ret = addCase.call(this, ...args)
    addWidthAttr(ret.ele)
    return ret
  }
  
  processing.addBayCase = function(...args) {
    let ret = addBayCase.call(this, ...args)
    addWidthAttr(ret.ele)
    return ret
  }
  
  processing.addGroundCase = function(...args) {
    let ret = addGroundCase.call(this, ...args)
    addWidthAttr(ret.ele)
    return ret
  }

  processing.addDoor = function(...args) {
    let ret = addDoor.call(this, ...args)
    addWidthAttr(ret.ele)
    addStartAttr(ret.ele)
    return ret
  }
  
  processing.addSlideDoor = function(...args) {
    let ret = addSlideDoor.call(this, ...args)
    addWidthAttr(ret.ele)
    return ret
  }

  processing.adddDoubleDoor = function(...args) {
    let ret = adddDoubleDoor.call(this, ...args)
    addWidthAttr(ret.ele)
    return ret
  }

  processing.addColumn = function(...args) {
    let ret = addColumn.call(this, ...args)
    addWidthAttr(ret.ele)
    addTickAttr(ret.ele)
    return ret
  }

  processing.addLine = function(...args) {
    let ret = addLine.call(this, ...args)
    return ret
  }



  let addFurnWidthAttr = (ele: Furn) => {
    Object.defineProperties(ele, {
      // 修改宽度
      ewidth: {
        get: () => Number(lineDis({points: [ele.points[0], ele.points[1]]}).toFixed(2)),
        set: (val) => {
          if (val <= 0 || val === ele.ewidth) return;
          let newLine1 = lineStretch( { points: [ele.points[0], ele.points[1]] }, val )
          let newLine2 = lineStretch( { points: [ele.points[2], ele.points[3]] }, val )
          let points = newLine1.points.concat(newLine2.points)

          if (ele.check(points)) {
            ele.directUpdate(points)
          }
        }
      },
      // 最大宽度
      maxWidth: {
        get: () => {
          return 10
        }
      },
      minWidth: {
        get: () => 0
      }
    })
  }

  let addFurnTickAttr = (ele: Furn) => {
    Object.defineProperties(ele, {
      tick: {
        get: () => {
          return Number(lineDis({points: [ele.points[1], ele.points[2]]}).toFixed(2))
        },
        set: (val) => {
          if (val <= 0 || val === ele.tick ) return;
          let newLine1 = lineStretch( { points: [ele.points[0], ele.points[3]] }, val )
          let newLine2 = lineStretch( { points: [ele.points[1], ele.points[2]] }, val )
          let points = [newLine1.points[0], newLine2.points[0], newLine2.points[1], newLine1.points[1]]

          if (ele.check(points)) {
            ele.directUpdate(points)
          }
        }
      },
      // 最大宽度
      maxTick: {
        get: () => {
          return 10
        }
      },
      minTick: {
        get: () => 0
      }
    })
  }


  let addFurnAngleAttr = (ele: Furn) => {
    Object.defineProperties(ele, {
      maxAngle: {
        get: () => 360
      },
      minAngle: {
        get: () => 0
      }
    })
  }

  
  processing.addFurnColumn = function(...args) {
    let ret = addFurnColumn.call(this, ...args)
    addFurnWidthAttr(ret.ele)
    addFurnTickAttr(ret.ele)
    addFurnAngleAttr(ret.ele)
    return ret
  }

  processing.addFurnFlue = function(...args) {
    let ret = addFurnFlue.call(this, ...args)
    addFurnWidthAttr(ret.ele)
    addFurnTickAttr(ret.ele)
    addFurnAngleAttr(ret.ele)
    return ret
  }

}

// 拦截arch门窗柱子墙线条添加方法， 添加额外属性
export default (cad: AttachCAD) => {
  const addProcessing = cad.addProcessing
  cad.addProcessing = (...args) => {
    let processing = addProcessing.call(cad, ...args)

    attrAdd(cad, processing)
    return processing
  }
}