; MEXPLODE.LSP : X, Y 비율이 다른 BLOCK을 EXPLODE하는 프로그램
; 작성일       : 1994. 10. 2.
; 작성자       : 최문선

; 전역변수
; #MODEL      : 시스템 변수값을 임시로 저장할 리스트
; #SFLAG      : X, Y, Z 스케일이 모두 같으면 T, 아니면 nil

(setq #MODEL nil)
(setq #SFLAG nil)

; 사용할 시스템 변수의 현재값을 대피시킨다.
; 해당 시스템 변수의 값을 설정한다.

(defun push-mode ()
    (setq #MODEL (list (getvar "BLIPMODE")
                       (getvar "CMDECHO")
                       (getvar "EXPERT")
                       (getvar "OSMODE")
                 )
    )
    (setvar "BLIPMODE" 0)
    (setvar "CMDECHO" 0)
    (setvar "EXPERT" 1)
    (setvar "OSMODE" 0)
)

; 대피시켜둔 시스템 변수의 값을 복구시킨다.

(defun pop-mode ()
    (setvar "BLIPMODE" (car #MODEL))
    (setvar "CMDECHO" (cadr #MODEL))
    (setvar "EXPERT" (caddr #MODEL))
    (setvar "OSMODE" (cadddr #MODEL))
    (princ)
)

; 사용자 정의 에러 처리 함수
; 시스템 변수의 값을 복구시킨다.

(defun *ERROR* (msg)
    (if (/= msg "Function cancelled")
        (if (= msg "quit / exit abort")
            (princ)
            (princ (strcat "\nError: " msg "\n"))
        )
        (princ)
    )
    (redraw)
    (pop-mode)
)

; 주어진 엔티티 이후에 생성된 모든 엔티티들을 하나의 selection-set으로 만든다.

(defun pick-entity (el / ss)
    ; 새로운 selection-set을 만든다.
    (setq ss (ssadd))
    ; 더 이상 엔티티가 없을 때까지 수행
    (while (setq el (entnext el))
        ; selection-set에 엔티티를 추가
        (setq ss (ssadd el ss))
    )
    ; 결과 selection-set을 반환
    ss
)

; ARRAY 

(defun multi-array (ss cc rc cs rs ang / oang)
    (setq oang (getvar "SNAPANG"))
    (setvar "SNAPANG" ang)
    (setq ang (/ (* ang 180.0) PI))
    (if (and (< 1 cc) (< 1 rc))
        (command "ARRAY" ss "" "R" rc cc rs cs)
        (if (< 1 cc)
            (command "ARRAY" ss "" "R" "1" cc cs)
            (if (< 1 rc)
                (command "ARRAY" ss "" "R" rc "1" rs)
            )
        )
    )
    (setvar "SNAPANG" oang)
)

; 좌표변환을 수행한다.

(defun calc-xpoint (po sc ang bp / rp)
    (setq po (mapcar '* po sc))
    (if (= ang 0.0)
        (setq rp po)
        (setq rp (list (- (* (car po) (cos ang)) (* (cadr po) (sin ang)))
                       (+ (* (car po) (sin ang)) (* (cadr po) (cos ang)))
                 )
        )
    )
    (mapcar '+ bp rp)
)

; 점 데이타를 변경

(defun subst-point (num sc ang bp el)
    (subst (cons num (calc-xpoint (cdr (assoc num el)) sc ang bp)) 
           (assoc num el) el)
)

; 점이 한개인 엔티티에 대한 처리

(defun point1-exp (sc ang bp el)
    (subst-point 10 sc ang bp el)
)

; 점이 두개인 엔티티에 대한 처리

(defun point2-exp (sc ang bp el)
    (setq el (subst-point 10 sc ang bp el))
    (setq el (subst-point 11 sc ang bp el))
)

; 점이 네개인 엔티티에 대한 처리

(defun point4-exp (sc ang bp el)
    (setq el (subst-point 10 sc ang bp el))
    (setq el (subst-point 11 sc ang bp el))
    (setq el (subst-point 12 sc ang bp el))
    (setq el (subst-point 13 sc ang bp el))
)

; ARC에 대한 처리

(defun arc-exp (sc ang bp el)
    (setq el (subst-point 10 sc ang bp el))
    (setq el (subst (cons 40 (* (cdr (assoc 40 el)) (car sc)))
                    (assoc 40 el) el))
    (setq el (subst (cons 50 (+ (cdr (assoc 50 el)) ang))
                    (assoc 50 el) el))
    (setq el (subst (cons 51 (+ (cdr (assoc 51 el)) ang))
                    (assoc 51 el) el))
)

; CIRCLE에 대한 처리

(defun circle-exp (sc ang bp el)
    (setq el (subst-point 10 sc ang bp el))
    (setq el (subst (cons 40 (* (cdr (assoc 40 el)) (car sc)))
                    (assoc 40 el) el))
)

; 블럭을 분리

(defun insert-exp (sc ang bp el)
    (setq el (subst-point 10 sc ang bp el))
    (setq el (subst (cons 41 (* (cdr (assoc 41 el)) (car sc)))
                    (assoc 41 el) el))
    (setq el (subst (cons 42 (* (cdr (assoc 42 el)) (cadr sc)))
                    (assoc 42 el) el))
    (setq el (subst (cons 43 (* (cdr (assoc 43 el)) (caddr sc)))
                    (assoc 43 el) el))
    (setq el (subst (cons 50 (+ (cdr (assoc 50 el)) ang))
                    (assoc 50 el) el))
)

; 각 블럭을 엔티티로 분해

(defun exp-block (en sc ang bp cl / dflag el etype flag)
    (setq dflag T)
    (while en
        (setq el (entget en))
        (setq etype (cdr (assoc 0 el)))
        (setq flag T)
        (cond 
            ((= etype "3DFACE")   (setq el (point4-exp sc ang bp el)))
            ((= etype "INSERT")   (setq el (insert-exp sc ang bp el)))
            ((= etype "LINE")     (setq el (point2-exp sc ang bp el)))
            ((= etype "POINT")    (setq el (point1-exp sc ang bp el)))
            ((= etype "POLYLINE") T)
            ((= etype "SEQEND")   T)
            ((= etype "SOLID")    (setq el (point4-exp sc ang bp el)))
            ((= etype "TRACE")    (setq el (point4-exp sc ang bp el)))
            ((= etype "VERTEX")   (setq el (point1-exp sc ang bp el)))
            (T
                (if (and #SFLAG (or (= etype "ARC") (= etype "CIRCLE")))
                    (if (= etype "ARC")
                        (setq el (arc-exp sc ang bp el))
                        (setq el (circle-exp sc ang bp el))
                    )
                    (progn
                        ; EXPLODE 할 수 없는 엔티티인 경우
                        (princ (strcat "\nError! Unable to explode " etype " entity"))
                        ; 삭제 flag과 생성 flag 을 nil로 설정
                        (setq dflag nil flag nil)
                    )
                )
            )
        )
        ; 각각의 엔티티를 변형된 형태로 재 생성한다.
        (if flag (entmake (subst (cons 8 cl) (assoc 8 el) el)))
        (setq en (entnext en))
    )
    dflag
)

; 블럭에 대한 EXPLODE 수행

(defun exp-insert (en / le el sc cnt rcnt clyr bp rz bn cspc rspc ent dflag ss)
    (setq le (entlast))
    (setq el (entget en))
    ; 블럭의 X, Y, Z scale과 열, 행의 수, 레이어명을 구한다.
    (setq sc (list (cdr (assoc 41 el)) (cdr (assoc 42 el)) (cdr (assoc 43 el)))
          ccnt (cdr (assoc 70 el))
          rcnt (cdr (assoc 71 el))
          clyr (cdr (assoc 8 el))
    )
    (if (and (and (= (car sc) (cadr sc)) (= (cadr sc) (caddr sc)))
             (and (= ccnt 0) (= rcnt 0))
        )
        ; X, Y, Z scale이 모두 같고, MINSERT 된 것이 아니면 수행
        (command "EXPLODE" en)
        (progn
            (if (or (/= ccnt 0) (/= rcnt 0))
                (princ "\nWarning! Cannot explode a MINSERTed block");
            )
            (if (or (/= (abs (car sc)) (abs (cadr sc)))
                    (/= (abs (cadr sc)) (abs (caddr sc))))
                (progn
                    (princ "\nWarning! X, Y, and Z scale factors must be equal.")
                    (setq #SFLAG nil)
                )
                (setq #SFLAG T)
            )
            ; 블럭의 삽입점, 회전각, 블럭명, 열, 행의 간격을 구한다.
            (setq bp (cdr (assoc 10 el))
                  rz (cdr (assoc 50 el))
                  bn (cdr (assoc 2 el))
                  cspc (cdr (assoc 44 el))
                  rspc (cdr (assoc 45 el))
            )
            ; 블럭의 시작 엔티티의 이름을 구한다.
            (setq ent (cdr (assoc -2 (tblsearch "BLOCK" bn))))
            ; 블럭을 각각의 엔티티로 분해한다.
            (setq dflag (exp-block ent sc rz bp clyr))
            ; dflag이 T이면 EXPLODE 되기전 엔티티를 지운다.
            (if dflag (entdel en))
            ; MINSERT된 블럭이면 EXPLODE 된 엔티티들을
            ; 이용하여 ARRAY 작업을 수행한다.
            (if (or (/= ccnt 0) (/= rcnt 0))
                (progn
                    (setq ss (pick-entity le))
                    (if ss (multi-array ss ccnt rcnt cspc rspc rz))
                )
            )
        )
    )
)

; 엔티티 종류에 따른 EXPLODE 수행

(defun ent-explode (en / etype)
    (setq etype (cdr (assoc 0 (entget en))))
    (cond ((= etype "DIMENSION") (command "EXPLODE" en))
          ((= etype "INSERT")    (exp-insert en))
          ((= etype "POLYLINE")  (command "EXPLODE" en))
          (T
             (princ "\nNot a block reference, polyline, mesh, or dimension."))
    )
)

; 새로운 EXPLODE 과정

(defun max-explode (ss / sl el in)
    (setq sl (sslength ss))
    ; EXPLODE된 모든 엔티티들을 하나의 selection-set으로 
    ; 만들기 위해 마지막 엔티티의 이름을 알아둔다.
    (setq el (entlast))
    ; 엔티티 번호를 0으로 설정
    (setq in 0)
    (while (< in sl)
        (setq en (ssname ss in))
        ; 엔티티 종류에 따른 EXPLODE 수행
        (ent-explode en)
        (setq in (1+ in))
    )
    ; EXPLODE된 모든 엔티티들을 하나의 selection-set으로 만든다.
    (setq ss (pick-entity el))
    ; 만들어진 selection-set을 previous selection-set으로 만든다.
    (command "SELECT" ss "")
)

; 전체 프로그램을 C:MEXPLODE 함수로 정의한다.

(defun C:MEXPLODE ( / ss)
    (push-mode)
    ; EXPLODE 할 대상들이 선택되면 새로운 EXPLODE 과정 수행
    (if (setq ss (ssget)) 
        (max-explode ss)
    )
    (pop-mode)
)