cad_house/src/CAD/core/base/processing/index.ts

import Render from '../renderer'
import Point from '../../core/point'
import WallLine from '../../core/wallline'
import Casement from '../../architecture/casement'
import Door from '../../architecture/door/index'
import DoubleDoor from '../../architecture/doubleDoor'
import Column from '../../architecture/column'
import FurnColumn from '../../furniture/column'
import FurnFlue from '../../furniture/flue'
import { CADElementTS } from '../../core/element'
import Tagging from '../../label/tagging'
import SlideDoor from '../../architecture/slideDoor'
import GroundCase from '../../architecture/groundCase'
import { methods as toEleMethods, ToEle } from './toEle'
import { methods as roomMethods, RoomApi } from './room'
import { methods as dataMethods, dataApi } from './toData'
import { methods as pointOperMethods, PointOper } from './pointOper'
import BayCase from '../../architecture/bayCase'
import {AttachCAD} from '../../index'
import Sign from '../../label/sign'
import Direction from '../../label/direction'
import Route from '../../label/route'


export interface _Point { x: number, y:number, id: number }
export interface _Line { p1: number, p2: number, id: number, border: boolean, exterior?: boolean }
export interface _window { pos: Array<number>, line: number  }
export interface _door { pos: Array<number>, line: number, within: number, show?: boolean, ctl?: Array<number>, start: boolean }
export interface _doubledoor { pos: Array<number>, line: number, within: number, show?: boolean, ctl?: Array<number>, start: boolean }
export interface _slideDoor { pos: Array<number>, line: number, within: number }
export interface _groundCase { pos: Array<number>, line: number }
export interface _bayCase { pos: Array<number>, line: number, within: number, ctl?: Array<number> }
export interface _column { pos: Array<number>, line: number }
export interface _furnColumn { pos: Array<number>,  angle: number }
export interface _furnFlue { pos: Array<number>,  angle: number }
export interface _tagging { pos: Array<number>, title: string, content: string, showTitle: boolean, showContent: boolean}
export interface _hole {pos: Array<number>, top: number}
export type _Ground = Array<number>
export interface _room { id: number, ground: _Ground, hole: Array<_hole>, close: boolean }
export interface Data {
  show: boolean,
  id: number,
  room?: Array<{
    wall: Array<number>,
    ground: Array<number>
  }>,
  vertex: Array<_Point>,
  surplus: Array<_Point>,
  wall: Array<_Line>,
  window: Array<_window>,
  door: Array<_door>,
  column: Array<_column>,
  furnColumn: Array<_furnColumn>,
  doubleDoor: Array<_doubledoor>
  furnFlue: Array<_furnFlue>,
  slideDoor: Array<_slideDoor>
  groundCase: Array<_groundCase>,
  bayCase: Array<_bayCase>,
  tagging: Array<_tagging>,
  dire: number
}
export interface FloorData {
  floors: Array<Data>
}
export interface StorageProps{ dom: HTMLElement }
export interface CADState {elements: Array<Point>}
export interface rhole extends _hole {bottom: number} 
export type Walls = Array<{ id: number; ele: WallLine, border: boolean, exterior?: boolean, isOut?: boolean }>
export type Points = Array<{ id: number; ele: Point }>
export type Cases = Array<{ele: Casement}>
export type Doors = Array<{ele: Door}>
export type SlideDoors = Array<{ele: SlideDoor}>
export type GroundCases = Array<{ele: GroundCase}>
export type Columns = Array<{ele: Column}>
export type FurnColumns = Array<{ele: FurnColumn}>
export type FurnFlues = Array<{ele: FurnFlue}>
export type Taggings = Array<{ele: Tagging}>
export type BayCases = Array<{ele: BayCase}>
export type DoubleDoors = Array<{ele: DoubleDoor}>

export class _Processing {
  data: Data
  render: Render
  points: Points
  lines: Walls
  cases: Cases
  id: number
  show: boolean
  doors: Doors
  slideDoors: SlideDoors
  groundCases: GroundCases
  bayCases: BayCases
  doubleDoors: DoubleDoors
  columns: Columns
  taggings: Taggings
  insertModel: boolean
  furnColumns: FurnColumns
  furnFlues: FurnFlues
  direction: Direction
  sign: Sign
  rote: Route
  cad: AttachCAD
  
  constructor({dom}: StorageProps) {
    this.render = new Render({ layer: dom, processing: (this as unknown as ProcessingTS) })
    this.id = 1
    this.points = []
    this.lines = []
    this.cases = []
    this.doors = []
    this.columns = []
    this.slideDoors = []
    this.groundCases = []
    this.taggings = []
    this.bayCases = []
    this.furnColumns = []
    this.furnFlues = []
    this.doubleDoors = []
    this.manageShow()
  }

  private manageShow() {
    let show = false

    Object.defineProperty(this, 'show', {
      get: () => show,
      set: (val) => {
        console.log('---------', show)
        show = val
        this.render.svg.style.display = show ? 'block': 'none'
      }
    })
    
  }


  // 删除元素
  rep(this: ProcessingTS, ele: CADElementTS) {
    this.attrs.forEach(attr => {
      let index = this[attr].findIndex(({ele: e}) => e === ele)

      if (~index) {
        ele.__id = this[attr][index] && this[attr][index].id
        this[attr].splice(index, 1)
      }
    })
    if (!this.render) {
      console.error('掉用 rep')
    }
    this.render && this.render.remove(ele)
  }

  // Element加装Destroy方法
  retrofitElementDestroy (this: ProcessingTS,ele: CADElementTS) {
    let destroy = ele.destroy
    if (ele.__load_destroy) return;
    ele.__load_destroy = true
    ele.destroy = (...args) => {
      // 需要同步删除还是更新完属性后删除
      if ((args as any)[0]) {
        this.rep(ele)
      } else {
        ele.nextTick(() => this.rep(ele))
      }
      destroy.call(ele, ...args)
      ele.__load_destroy = false
    }
  }

  updateWallPoints(this: ProcessingTS, ele: WallLine, oldPoints: [Point, Point], newPoints: [Point, Point]) {
    
  }
  
  // Element加装Destroy方法
  retrofitElementIntercept (this: ProcessingTS, ele: WallLine) {
    return;
    
  }

  depLines() {
    let lines = [...this.lines]
    for (let i = 0; i< lines.length; i++) {
      let line = lines[i].ele
      let ret = lines.some(({ele: eline}) => 
        line !== eline && (
          (line.points[0] === eline.points[0] && line.points[1] === eline.points[1]) ||
          (line.points[1] === eline.points[0] && line.points[0] === eline.points[1])
        )
      )

      if (line.points[0] === line.points[1] || ret) {
        lines[i].ele.destroy()
        lines.splice(i--, 1)
      }
    }
  }


  destroy(this: ProcessingTS) {
    let elesArr = this.attrs.map(attr => this[attr])
    this.data = {
      id: 1,
      show: true,
      vertex: [],
      wall: [],
      window: [],
      column: [],
      door: [],
      surplus: [],
      slideDoor: [],
      tagging: [],
      groundCase: [],
      bayCase: [],
      doubleDoor: [],
      furnColumn: [],
      furnFlue: [],
      dire: 0
    }
    elesArr.forEach(eles => {
      while (eles.length)
        eles[0].ele.destroy(true)
    })
    this.render.destroy()
    this.render = null
  }
}

export type ProcessingTS = _Processing & ToEle & RoomApi & dataApi & PointOper
export default _Processing as unknown as {
  new (data: StorageProps): ProcessingTS
}
export type That = {
  [k in any]: ((this: ProcessingTS, ...args) => any)
}

const apis = {
  ...toEleMethods,
  ...roomMethods,
  ...dataMethods,
  ...pointOperMethods
}
Object.keys(apis).forEach(
  k => _Processing.prototype[k] = apis[k]
)