;;; setlayer  Setzt den Layer *username* auf aktiv, entsperrt, getaut und ein
(defun setlayer()
  ; Überprüfen ob der Layer gefroren ist
  (if (= (vla-get-freeze *Layer*) :vlax-true)
    (vla-put-freeze *Layer* :vlax-false)  ; Layer tauen
  )

  ; Überprüfen ob der Layer gesperrt ist
  (if (= (vla-get-lock *Layer*) :vlax-true)
    (vla-put-lock *Layer* :vlax-false)   ; Layer entsperren
  )

  ; Überprüfen ob der Layer ausgeschaltet ist
  (if (= (vla-get-LayerOn *Layer*) :vlax-false)
    (vla-put-LayerOn *Layer* :vlax-true) ; Layer einschalten
  )
  (setvar "CLAYER" (vla-get-Name *Layer*)) ; Layer aktiv setzen
)

;;; getActiveLayer RetVal VLA-Object "LAYER"
(defun getActiveLayer()
  (vla-get-Activelayer *activeDoc* *acad*)
)

;;; getActiveLayerName RetVal String "LayerName"
(defun getActiveLayerName()
  (vla-get-name (vla-get-Activelayer *activeDoc* *acad*))
)

;;; getLayer(String)  RetVal VLA-Object "LAYER"
(defun getLayer(LayerName / Layer)
  (setq Layer nil)
  (vlax-for item *Layers*
    (if (= (vla-get-name item) LayerName)
      (setq Layer item)
    )
  )
  Layer
)

;;; f:setUserLayer   am Start eines Kommandos wird der Layer umgestellt
(defun f:setUserlayer(reactor command-list / cmdName)
  (setq reactorData (vlr-data reactor))
  (setq cmdName(car command-list))	; CommandoName z.B. "LINE"
  
  (if (not *Layer*)
    (progn
      (setq *Layer* (getLayer *username*))
      (setq *oldLayer* (getvar "CLAYER"))
      (if (member cmdName *cmdNames*)
        (setLayer)
      )
    )
  )
)

;;; f:setPreviousLayer   am Ende des Kommandos wird der vorherige Layer gesetzt
(defun f:setPreviousLayer(reactor command-list / cmdName)
  (setq reactorData (vlr-data reactor))
  (setq cmdName(car command-list))

  (setq *Layer* (getLayer *oldLayer*))
  (if (member cmdName *cmdNames*)
    (setLayer)
    (progn
      (setq cmddat(open (strcat (vla-get-fullname *activedoc*) ".txt") "a"))
      (write-line (strcat "\"" cmdName "\"") cmddat)       ; Ausgabe eines Befehls der nicht in *cmdNames* definiert ist (Nur zu Testzwecken)
      (setq cmddat(close cmddat))	                  ; in eine Datei um diese Befehle einfach und schnell in das Programm übernehmen zu können
    )
  )
  (setq *Layer* nil
        *oldLayer* nil
  )


)

(defun f:setUserName()
  (if (not *username*)          ; Abfrage ob der Layername schon vergeben wurde
      (setq *Lname* "Elektro")  ; Wenn nicht LayerVorgabeName auf Elektro setzen
      (setq *Lname* *username*) ; Ansonsten vorhandenen Layernamen verwenden
  )
  (initget (strcat (setq uname(getenv "username")) " Elektro Wasser Gas Removereactor Loadreactor")) ; Bewirkt dass nichts anderes als Elektro Wasser oder Gas eingegeben werden kann
  (setq *username*
    (getkword (strcat
                      "\nLayername der verwendet werden soll? "
                      (cond
                        ((= *Lname* uname) (strcat "[<" uname ">/Elektro/Wasser/Gas/Removereactor/Loadreactor] "))
                        ((= *Lname* "Elektro") (strcat "[" uname "/<Elektro>/Wasser/Gas/Removereactor/Loadreactor] "))
                        ((= *Lname* "Wasser")  (strcat "[" uname "/Elektro/<Wasser>/Gas/Removereactor/Loadreactor] "))
                        ((= *Lname* "Gas")     (strcat "[" uname "/Elektro/Wasser/<Gas>/Removereactor/Loadreactor] "))
                      )
                      "(Für Vorgabe <> einfach Enter drücken) "
              )
    )
  )
  (if (not *username*)              ; Wenn Enter gedrückt wurde Vorgabe verwenden
    (setq *username* *Lname*)
    (cond
      ((= *username* "Removereactor")
       (progn
         (setq *username* *Lname*)
         (cleanreactors)
         (setq *abbruch* T)
       )
      )
      ((= *username* "Loadreactor")
       (progn
         (setq *abbruch* nil)
         (setq *username* *Lname*)
         (LayerReactor)
       )
      )
      (T (setq *Lname* *username*
               *abbruch* nil
         )
      )
    )
  )
  *username*
)
; mit der Funktion kannst du den Layer auch noch umstellen wenn der Reactor schon erstellt wurde
; Einfach an der Befehlszeile von AutoCAD "setUserName" eingeben (ohne "") und du kannst den
; zu verwendenden LayerNamen eingeben

(defun c:setUserName()
  (f:setUserName)
  (if (not *abbruch*)
    (if (not (tblsearch "LAYER" *username*))
      (vla-add *Layers* *username*)
    )
    (alert "Alle Reactoren wurden entfernt")
  )
  (prin1)
)

(defun LayerReactor()
  (vl-load-com)
  (vl-load-reactors)

  (setq *acad*(vlax-get-acad-object)
        *activeDoc*(vla-get-activedocument *acad*)
        *Layers*(vla-get-layers *activeDoc*)
        *Layer* nil

        *username* (f:setUserName)

        *oldLayer* nil
        *cmdNames* '("DIMLINEAR""DIMALIGNED"
                     "DIMRADIUS""DIMANGULAR"
                     "DIMBASELINE""DIMDIAMETER"
                     "DIMCONTINUE""QLEADER"
                     "LINE" "PLINE" "CIRCLE" "ELLIPSE"
                     "TEXT" "DTEXT" "MTEXT"
                     "RAY" "XLINE" "SPLINE"
                     "BHATCH" "HATCH" "SOLID"
                     "RECTANG" "REVCLOUD" "POLYGON"
                     "ARC" "INSERT" "TABLE"
                     "MLINE" "3DPOLY" "DONUT"
                     "BOUNDARY" "REGION" "WIPEOUT"

                    )
  )
  (if (not (tblsearch "LAYER" *username*))
    (vla-add *Layers* *username*)
  )
  (if *commandReactor*
    (progn
      (setq *commandReactor* nil)
      (vlr-remove-all :VLR-Command-Reactor)
    )
  )
  (setq *commandReactor*
         (VLR-Command-Reactor
           nil				; No data is associated with the command reactor
           '(
             (:vlr-commandWillStart . f:setUserlayer)
             (:VLR-commandEnded     . f:setPreviousLayer)
             (:VLR-commandFailed    . f:setPreviousLayer)
             (:VLR-commandCancelled . f:setPreviousLayer)
            )
         )
  )

  (if (not *DrawingReactor*)
    (setq *DrawingReactor*
       (VLR-DWG-Reactor
         nil			; No data is associated with the drawing reactor
         '(
           ;; This is extremely important!!!!!!!!!
           ;; Without this notification, AutoCAD will
           ;; crash upon exiting.
           (:vlr-beginClose . f:clean-all-reactors)
          )
       ) ;_ end of vlr-editor-reactor
    )
  )
)

;;;--------------------------------------------------------------------;
;;;     Function: CleanReactors                                        ;
;;;--------------------------------------------------------------------;
;;;  Description: This is a general utility function used for cleaning ;
;;;               up reactors. It can be used during debugging, as     ;
;;;               well as cleaning up any open reactors before a       ;
;;;               drawing is closed.                                   ;
;;;--------------------------------------------------------------------;
(defun CleanReactors ()
  (setq	*commandReactor* nil		; clear the variable
	*DrawingReactor* nil		; clear the variable
	)
  (mapcar 'vlr-remove-all
	  '(:VLR-AcDb-reactor		 :VLR-Editor-reactor
	    :VLR-Linker-reactor		 :VLR-Object-reactor
	    ;; new reactors
	    ;; New for AutoCAD 2000
	    :VLR-Command-Reactor	 :VLR-DeepClone-Reactor
	    :VLR-DocManager-Reactor	 :VLR-DWG-Reactor
	    :VLR-DXF-Reactor		 :VLR-Editor-reactor
	    :VLR-Insert-Reactor		 :VLR-Linker-Reactor
	    :VLR-Lisp-Reactor		 :VLR-Miscellaneous-Reactor
	    :VLR-Mouse-Reactor		 :VLR-Object-Reactor
	    :VLR-SysVar-Reactor		 :VLR-Toolbar-Reactor
	    :VLR-Undo-Reactor		 :VLR-Wblock-Reactor
	    :VLR-Window-Reactor		 :VLR-XREF-Reactor
	    )
	  ) ;_ end of mapcar
  ) ;_ end of defun

;;;--------------------------------------------------------------------;
;;;     Function: f:clean-all-reactors                                 ;
;;;--------------------------------------------------------------------;
;;;  Description: Used to clean all reactors before exiting AutoCAD.   ;
;;;               This is a Very Important Function!                   ;
;;;--------------------------------------------------------------------;
(defun f:clean-all-reactors (reactor command-list)
  (setq reactorData (vlr-data reactor))
  (cleanReactors)
) ;_ end of defun

(LayerReactor)