;
; Dieses LISP ersetzte nach der Testphase (vom 01.07.2025 bis 19.08.2025) folgendes, auf 
; Expresstools basierendes, Makro:
; ^C^CGETSEL;\;(defun c:LetzteAuswahl ()(sssetfirst nil (ssget"_P")));LetzteAuswahl;
;
; Das LISP stellt 3 Befehle zur Verfügung: "AUSWAHL_NACH_LAYER", "AUSWAHL_ERWEITERN" und "AUSWAHL_REDUZIEREN"
; Die zwei letzten Befehle müssen unmittelbar nach dem ersten Befehl "AUSWAHL_NACH_LAYER" eingegeben
; werden um zu funktionieren... Das LISP ist mit KI (Gemini, DeepSeek, Grok) erstellt/mutiert worden.
;
; Hauptbefehl - Erste Auswahl: AUSWAHL_NACH_LAYER
; Der User wählt Elemente und bestätigt mit Rechter Maustaste. Danach sind
; alle Elmente der involvierten Layer markiert für weitere Ausgaben oder einfach zum Sehen, was sonst
; noch so alles auf diesen Layern ist.
;
; Ergänzungsbefehl - Erweitert die bestehende Auswahl: AUSWAHL_ERWEITERN
; Das funktioniert aber nur unmittelbar nach dem Befehl "AUSWAHL_NACH_LAYER"
;
; Ergänzungsbefehl - Reduziert die bestehende Auswahl: AUSWAHL_REDUZIEREN
; Das funktioniert aber nur unmittelbar nach den Befehlen "AUSWAHL_NACH_LAYER" oder "AUSWAHL_ERWEITERN"
;
; v0.1 bis x0.3 BETA Versionen 
;
; v1.0 Stabile Version war in Betrieb vom 19.08.2025 bis 27.10.2026
;
; v1.1 Zusatzfunktion zum wählen des aktuellen Layers beim Drücken von "a" in den Befehlen
; "AUSWAHL_NACH_LAYER" sowie "AUSWAHL_ERWEITERN". Ausserdem wurde testweise (command "REGEN") ausgeklammert.
;
;
;
;
; Bekannte Probleme:
; - Seit V1.1 muss der erste Klick auf einem Element oder ins Leere sein. Ein direktes Auswahlfenster
;   (oder Kreuzenfenster) ist nicht mehr möglich.
;
(defun c:AUSWAHL_NACH_LAYER (/ ss ssLayer i ent layer layerSS j entList clayer gr done pt ssTmp)
  (vl-load-com)
  (sssetfirst nil nil)

  (princ "\nObjekte wählen oder [A für aktueller Layer]: ")
  (setq done nil
        pt nil)

  (while (not done)
    (setq gr (grread T 15 2))
    (cond
      ((and (= (car gr) 2) (member (cadr gr) '(65 97)))
       (setq done "Aktuell")
      )
      ((= (car gr) 3)
       (setq pt (cadr gr)
             done "Maus")
      )
      ((member (car gr) '(2 25))
       (setq done "Maus")
      )
    )
  )

  (if (= done "Aktuell")
    (progn
      (setq clayer (getvar "CLAYER"))
      (setq ss (ssget "_X" (list (cons 8 clayer))))
      (if ss
        (progn
          (setq ssLayer (ssadd))
          (setq i (sslength ss))
          (repeat i
            (setq ent (ssname ss (setq i (1- i))))
            (if (not (ssmemb ent ssLayer))
              (ssadd ent ssLayer)
            )
          )
          (sssetfirst nil ssLayer)
          ;(command "REGEN")
          (princ (strcat "\n" (itoa (sslength ssLayer)) " Objekte auf aktuellem Layer \"" clayer "\" ausgewählt."))
        )
        (princ (strcat "\nKeine Objekte auf aktuellem Layer \"" clayer "\" gefunden."))
      )
    )
    (progn
      (if pt
        (progn
          (setq ss (ssget pt))
          (if ss
            (progn
              (setq i (sslength ss))
              (repeat i
                (vla-highlight (vlax-ename->vla-object (ssname ss (setq i (1- i)))) :vlax-true)
              )
            )
          )
          (setq ssTmp (ssget))
          (cond
            ((and ss ssTmp)
             (repeat (setq i (sslength ssTmp))
               (setq ent (ssname ssTmp (setq i (1- i))))
               (if (not (ssmemb ent ss))
                 (ssadd ent ss)
               )
             )
            )
            (ssTmp (setq ss ssTmp))
          )
        )
        (setq ss (ssget))
      )
      (if ss
        (progn
          (setq ssLayer (ssadd))
          (setq entList '())
          (repeat (setq i (sslength ss))
            (setq ent (ssname ss (setq i (1- i))))
            (setq layer (cdr (assoc 8 (entget ent))))
            (if (not (member layer entList))
              (setq entList (cons layer entList))
            )
          )
          (foreach layer entList
            (setq layerSS (ssget "_X" (list (cons 8 layer))))
            (if layerSS
              (repeat (setq j (sslength layerSS))
                (setq ent (ssname layerSS (setq j (1- j))))
                (if (not (ssmemb ent ssLayer))
                  (ssadd ent ssLayer)
                )
              )
            )
          )
          (sssetfirst nil ssLayer)
          ;(command "REGEN")
          (princ (strcat "\n" (itoa (sslength ssLayer)) " Objekte ausgewählt."))
        )
        (princ "\nKeine Objekte ausgewählt.")
      )
    )
  )
  (princ)
)
(defun c:AUSWAHL_ERWEITERN (/ *error* ssExisting ssNew ssLayer i ent layer layerSS j entList clayer gr done pt ssTmp)
  (vl-load-com)

  (defun *error* (msg)
    (princ (strcat "\nFehler: " msg))
    (princ)
  )

  (setq ssExisting (ssget "_I"))

  (if (not ssExisting)
    (princ "\nKeine bestehende Auswahl gefunden. Bitte erst AUSWAHL_NACH_LAYER verwenden.")
    (progn
      (sssetfirst nil nil)

      (princ "\nWeitere Objekte wählen oder [A für aktueller Layer]: ")
      (setq done nil
            pt nil)

      (while (not done)
        (setq gr (grread T 15 2))
        (cond
          ((and (= (car gr) 2) (member (cadr gr) '(65 97)))
           (setq done "Aktuell")
          )
          ((= (car gr) 3)
           (setq pt (cadr gr)
                 done "Maus")
          )
          ((member (car gr) '(2 25))
           (setq done "Maus")
          )
        )
      )

      (if (= done "Aktuell")
        (progn
          (setq clayer (getvar "CLAYER"))
          (setq ssNew (ssget "_X" (list (cons 8 clayer))))
        )
        (if pt
          (progn
            (setq ssNew (ssget pt))
            (if ssNew
              (progn
                (setq i (sslength ssNew))
                (repeat i
                  (vla-highlight (vlax-ename->vla-object (ssname ssNew (setq i (1- i)))) :vlax-true)
                )
              )
            )
            (setq ssTmp (ssget))
            (cond
              ((and ssNew ssTmp)
               (repeat (setq i (sslength ssTmp))
                 (setq ent (ssname ssTmp (setq i (1- i))))
                 (if (not (ssmemb ent ssNew))
                   (ssadd ent ssNew)
                 )
               )
              )
              (ssTmp (setq ssNew ssTmp))
            )
          )
          (setq ssNew (ssget))
        )
      )

      (if (and ssNew (> (sslength ssNew) 0))
        (progn
          (setq ssLayer (ssadd))
          (repeat (setq i (sslength ssExisting))
            (ssadd (ssname ssExisting (setq i (1- i))) ssLayer)
          )

          (setq entList '())
          (repeat (setq i (sslength ssExisting))
            (setq ent (ssname ssExisting (setq i (1- i))))
            (setq layer (cdr (assoc 8 (entget ent))))
            (if (not (member layer entList))
              (setq entList (cons layer entList))
            )
          )

          (repeat (setq i (sslength ssNew))
            (setq ent (ssname ssNew (setq i (1- i))))
            (setq layer (cdr (assoc 8 (entget ent))))
            (if (not (member layer entList))
              (setq entList (cons layer entList))
            )
            (if (not (ssmemb ent ssLayer))
              (ssadd ent ssLayer)
            )
          )

          (foreach layer entList
            (setq layerSS (ssget "_X" (list (cons 8 layer))))
            (if layerSS
              (repeat (setq j (sslength layerSS))
                (setq ent (ssname layerSS (setq j (1- j))))
                (if (not (ssmemb ent ssLayer))
                  (ssadd ent ssLayer)
                )
              )
            )
          )

          (sssetfirst nil ssLayer)
          ;(command "REGEN")
          (princ (strcat "\n" (itoa (sslength ssLayer)) " Objekte (erweitert) ausgewählt."))
        )
        (progn
          (sssetfirst nil ssExisting)
          ;(command "REGEN")
          (princ "\nKeine zusätzlichen Objekte ausgewählt - Auswahl unverändert.")
        )
      )
    )
  )
  (princ)
)
(defun c:AUSWAHL_REDUZIEREN (/ ssExisting ssRemove ssReduced i ent layer removeLayers keepLayers layerSS j)
  (vl-load-com)
  
  ; 1. Bestehende Auswahl abfragen
  (setq ssExisting (ssget "_I"))
  
  (if (not ssExisting)
    (princ "\nKeine aktive Auswahl vorhanden!")
    (progn
      ; Temporär Griffe entfernen für neue Auswahl
      (sssetfirst nil nil)
      
      ; 2. Explizit nach Objekten fragen, deren Layer entfernt werden sollen
      (princ "\nObjekte wählen, deren Layer AUS der Auswahl entfernt werden sollen: ")
      (setq ssRemove (ssget))
      
      (if (and ssRemove (> (sslength ssRemove) 0))
        (progn
          ; 3. Zu entfernende Layer sammeln
          (setq removeLayers '())
          (repeat (setq i (sslength ssRemove))
            (setq ent (ssname ssRemove (setq i (1- i))))
            (setq layer (cdr (assoc 8 (entget ent))))
            (if (not (member layer removeLayers))
              (setq removeLayers (cons layer removeLayers))
            )
          )
          
          ; 4. Reduzierte Auswahl erstellen (filtert Originalauswahl)
          (setq ssReduced (ssadd))
          (setq keepLayers '())
          
          ; 5. Originalauswahl filtern (Layer die nicht in removeLayers sind)
          (repeat (setq i (sslength ssExisting))
            (setq ent (ssname ssExisting (setq i (1- i))))
            (setq layer (cdr (assoc 8 (entget ent))))
            
            (if (not (member layer removeLayers))
              (progn
                (ssadd ent ssReduced)
                (if (not (member layer keepLayers))
                  (setq keepLayers (cons layer keepLayers))
                )
              )
            )
          )
          
          ; 6. Alle Objekte auf verbleibenden Layern neu selektieren
          (setq ssLayer (ssadd))
          (foreach layer keepLayers
            (setq layerSS (ssget "_X" (list (cons 8 layer))))
            (if layerSS
              (repeat (setq j (sslength layerSS))
                (setq ent (ssname layerSS (setq j (1- j))))
                (if (not (ssmemb ent ssLayer))
                  (ssadd ent ssLayer)
                )
              )
            )
          )
          
          ; 7. Ergebnis anzeigen
          (if (> (sslength ssLayer) 0)
            (progn
              (sssetfirst nil ssLayer)
			  ;(command "REGEN")
              (princ (strcat "\nAuswahl reduziert auf " (itoa (sslength ssLayer)) " Objekte"))
            )
            (princ "\nKeine Objekte verbleiben nach Reduzierung!")
          )
        )
        (progn
          ; Falls keine Objekte gewählt: Originalauswahl wiederherstellen
          (sssetfirst nil ssExisting)
		  ;(command "REGEN")
          (princ "\nKeine Objekte gewählt - Auswahl unverändert")
        )
      )
    )
  )
  (princ)
)
(princ "\nBefehl geladen: AUSWAHL_NACH_LAYER, AUSWAHL_ERWEITERN und AUSWAHL_REDUZIEREN")
(princ "\nDie zwei letzten Befehle müssen unmittelbar nach dem ersten Befehl AUSWAHL_NACH_LAYER eingegeben werden um zu funktionieren!")
(princ) ;Sauberes Ende