Startseite

Über Jürgen A. Becker

Impressum

CAD-Dienstleistungen

Schulungsangebot

Archiv für die Kategorie „Visual-Lisp“

Visual Lisp - Objektsichtbarkeit -

Dienstag, 24. November 2009

Hier möchte ich eine kleine Routine vorstellen, die ausgewählte Objekte isoliert unabhängig der Layerzugehörigkeit.

Visual Lisp stellt die Funktion REDRAW zur Verfügung, die einseits Objekte sichtbar oder unsichtbar schaltet, anderseits sie als ausgewählt markiert.

Diese Funktion REDRAW wird in der folgenden Routine genutzt.

Zunächst werden alle Objekte der Zeichnung unsichtbar geschaltet, was bei größeren Zeichnungen etwas länger dauern könnte. Getestet habe ich es nicht.

Danach werden die vorab gewählten Objkete wieder eingeblendet.

Ein REGEN stellt alle Objekte wieder dar.

(defun c:Sichtbar( / i Ausw Ausw1 Element)
(setq i 0)
(setq Ausw (ssget))
;;;Alle Objekte der Zeichnung ausblenden
(setq Ausw1 (ssget "X"))
(while (< i (sslength Ausw1))
(setq Element (ssname Ausw1 i))
(redraw Element 2)
(setq i (+ i 1))
)
(setq i 0)
;;;die ausgewählten Objekte wieder einblenden
(while (< i (sslength Ausw))
(setq Element (ssname Ausw i))
(redraw Element 1)
(setq i (+ i 1))
)
)

 

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

Veröffentlicht in Visual-Lisp | Keine Kommentare »

Visual Lisp - Austauschen von Blockreferenzen -

Dienstag, 11. August 2009

Das Austauschen von Blöcken durch einen anderen Block ist mit dem Express-Tool “BockReplace” möglich. Dieses Tool tauscht allerdings die gesamten Blockreferenzen in der Zeichnung aus. Ein Austauschen einzelner Blockreferenzen ist nicht möglich.

Ich möchte hier eine Routine vorstellen, die Blockreferenzen austauscht, aber:

  • Eine Auswahl der auszutauschenden Blockreferenzen ist möglich
  • Der neue Block kann per Name oder per Auswahl gewählt werden
  • Eine globales Austauschen ist wie im Express-Tool möglich

Hier der Code:

(defun c:BlockSwap (/ hAntwort hEntity i hNeuerName hObjekt ss)
  (vl-load-com)

  (setq echo (getvar "cmdecho"))
  (setvar "cmdecho" 0)
  ;Einen Zurück-Marker setzen
  (command "._undo" "_be")
 
  ;Test, ob Blockreferenzen vorhanden sind
  (setq ss (ssget "x" '((0 . "INSERT"))))
  (setq i 0)
  (if (/= ss nil)
    (progn
     (initget "Einzelnt Global")
     (setq hAntwort (getkword
         "\nEinzelnt oder Global?[Einzelnt/Global]: "))
     (cond
     ((eq hAntwort "Einzelnt")
      (princ "\nAuszutauschende Blockreferenzen wählen:")
      (setq ss (ssget))
     )
     ((eq hAntwort "Global")
      (setq hEntity
          (entsel "\nAuszutauschende Blockreferenz auswählen:"))
      (if (/= hEntity nil)
        (progn
          (setq hEntity (entget (car hEntity)))
          (if (= (cdr (assoc 0 hEntity)) "INSERT")
            (setq ss
              (ssget "x" (list '(0 . "INSERT") (assoc 2 hEntity))))
            (progn
              (princ "\nKeine Blockreferenz gewählt!")
              (setq ss nil)
            );end progn
           );end if
         );end progn
       );end if
      )
     );end cond
     (if (/= ss nil)
      (progn
        (setq hNeuerName
          (getstring
            "\nZu ersetzender Blockname oder <Block wählen>: "))
       (if (= hNeuerName "")
       
         (progn ;Blockreferenz auswählen
            (if (/=
              (setq hEntity
                    (entsel "\nBlockreferenz auswählen:")) nil)
             (progn
                (setq hEntity (entget (car hEntity)))
                (if (= (cdr (assoc 0 hEntity)) "INSERT")
                  (setq hNeuerName (cdr (assoc 2 hEntity)))
                  (progn
                    (princ "\nKeine Blockreferenz gewählt!")
                    (setq ss nil)      
                  );end progn
                );end if
               );end progn
             );end if
          );end progn
       
          (progn
             ;Testen, ob der Blockname vorhanden ist.
             (if (= (tblobjname "BLOCK" hNeuerName) nil)
               ;;Blockname nicht vorhanden
               (setq ss nil)
              );end if
           );end progn
       
          );end if
         );end progn
        );end if         
        (if (/= ss nil)
          (progn
            (setq i (1- i))
            (while (setq hEntity (ssname ss (setq i (1+ i))))
             (setq hObjekt (vlax-ename->vla-object hEntity))
             (vla-put-name hObjekt hNeuerName)
             (vla-update hObjekt)
            );end while
           );end progn
         );end if

    );end progn
  );end if

  (command "._undo" "_end")
  (princ (strcat "\nEs wurden " (itoa i) " Blöcke ersetzt."))
  (setvar "cmdecho" echo)
  (princ)
)

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

Veröffentlicht in Visual-Lisp | Keine Kommentare »

Visual Lisp - Einfügen von Flächen-Schriftfeldern -

Montag, 10. August 2009

In Architektur-Zeichnungen werden häufig Flächenwerte in Räume eingetragen. Dieses ist ein etwas aufwendiges Verfahren, weil einerseits die Fläche berechnet und dann per Text-Befehl eingefügt werden muss.

Eine Arbeitserleichterung sind Felder, die Werte von Objekten oder der Zeichnung als Text in die Zeichnung darstellen.

Die Werte dieser Felder werden bei bestimmten Aktionen oder Befehle (z.B. Regenerierung) aktualisiert.

Diese Felder können manuell über den Befehl Schriftfeld oder aber auch mit Hilfe einer kleinen Visual-Lisp Routine eingefügt werden.

Dieses möchte ich hier erläutern:

Die Auswahl des Objektes ist ein normaler Vorgang, wie in jeder anderen Lisp-Routine. Die Innovation hier ist die Ermittlung der ObjektID per VL-Befehle, die vorher mit

(vl-load-com)

geladen werden müssen.

Der VL-Befehl vla-get-objectid ermittelt die ObjektID aus einem Objekt, welches aus einem Elementname mit

(vlax-ename->vla-object ...)

erzeugt wird.

Hier der Code:

(defun c:P-Area (/ ent strField objID
         P1 TextHoehe Winkel)
  (vl-load-com)
  (if (setq ent (entsel))
   (progn

    ;Objekteigenschaften werden ermmittelt
    ;nur LWPolylinien sind erlaubt
    (setq ent (car ent))

    (if (= (cdr (assoc 0 (entget ent))) "LWPOLYLINE")
      (progn
        ;Die Objekt ID wird ermittelt.
        (setq objID
          (vla-get-objectid
            (vlax-ename->vla-object ent)))

        ;Der Flächen-Text wird zusammengestellt
        (setq strField
         (strcat "A=%<\\AcObjProp Object(%<\\_ObjId "
           (rtos objID 2 0)
        ">%).Area \\f \"%lu2%pr2%ps[,m^2]%ds44%ct8[0.0001]%th46\">%"
         )
        );;;end setq
       
        ;Der Flächen-Text wird in die Zeichnung eingefügt.
        (setq p1 (getpoint "\nStartpunkt: "))
        (setq TextHoehe (getdist p1 "\nTexthöhe: "))
        (setq Winkel (getangle p1 "\nDrehwinkel: "))
        (command "._-text" p1 TextHoehe Winkel strField)

      )
      (princ
        "\nDas ausgewählte Objekt war keine LW-Polyline.")
    )
   )
   (princ "\nKein Objekt ausgewählt.")
 )
 (princ)
)

Nach Ausführung der Routine sollte der Flächentext in die Zeichnung eingefügt worden sein.

Flächentext innerhalb eines Raums

Flächentext innerhalb eines Raums

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

Veröffentlicht in Visual-Lisp | Keine Kommentare »

Visual Lisp - Übergabe von Daten in andere geöffnete Zeichnungen -

Freitag, 7. August 2009

Im Artikel: Visual LISP: Speichern eigener Daten in die Zeichnung - wurde beschrieben, wie Daten in das Blackboard Namespace mit den Funktionen

;;;Speichern der Daten in das Blackboard
(vl-bb-set 'symbol value)
;;;Einlesen der Werte aus dem Blackboard
(vl-bb-ref 'variable)

in das Blackboard geschrieben oder aus dem Blackboard gelesen wurden.

Sollen Werte in das Zeichnungs-Namespace geschrieben werden, werden die Funktionen

;;;Speichern einer Variable in Zeichnungs-Namespace
(setq s "Hallo")
(vl-doc-set 's)
;;;Auslesen der Variable
(vl-doc-ref 's)

Die Funktion

(vl-doc-ref ... )

ist equivalent mit der Funktion

(eval ... )

Die Funktion

(vl-doc-set ... )

ist equivalent mit der Funktion

(setq ... )

Eine weitere Möglichkeit um Variablen anderen Zeichnungen zur Verfügung zustellen, ist die Nutzung der Funktion:

(setq s "Hallo")
(vl-propagate 's)

 
Sie stellt Variablen in allen Zeichnungs-Namespaces zur Verfügung, stellt diese Variable aber auch in allen neuen Zeichnungen zur Verfügung.

Viel Spaß beim Ausprobieren

Autor: Dipl.-Ing. Jürgen A. Becker
Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

    • Veröffentlicht in Visual-Lisp | 2 Kommentare »

    Laden von Applikationen ins AutoCAD

    Mittwoch, 5. August 2009

    Ich möchte hier die Möglichkeiten des Ladens von Applikationen (Visual-Lisp, VBA, .NET etc.) in die AutoCAD-Umgebung diskutieren.

    Startgruppe

    Dialog: Appload (Startgruppe)

    Dialog: Appload (Startgruppe)

    Alle in diesem Dialog genannten Applikationen (*.lsp, *.vlx, *.dvb, *.arx, *.dll) werden beim Starten von AutoCAD und einer neuen Zeichnung geladen.

    Durch die Schaltfläche “Hinzufügen” können neue Applikationen aufgenommen werden. Achten Sie bitte auf die Reichenfolge, das kann für manche Applikationen wichtig sein. Die Ladereihenfolge stimmt nicht mit der Anzeigereihenfolge überein.

    Die Applikationen werden in der Registry des Betriebssystems gespeichert.

    Registry-Schlüssel:

    HKEY_USERS\S-1-5-21-2501896413-2501329306-742238524-1000\Software\Autodesk\AutoCAD\R18.0\ACAD-8001:407\Profiles\Jürgen\Dialogs\Appload\Startup

    Registry-Einträge der Startupgruppe

    Registry-Einträge der Startupgruppe

    Für jeden Applikationseintrag wird eine Zeichenfolge hinzugefügt. Der Name der erweiterbaren Zeichenfolge beginnt mit einem Zähler, und der folgenden Zeichenfolge “Startup” entsprechend der Anzahl der zu ladenden Applikationen.

    Die Zeichenfolge “NumStartup” beinhaltet die Anzahl der zuladenden Applikationen.

    Die ACADDOC.LSP Datei

    Die ACADDOC.LSP wird dazu benutzt um beim Öffnen oder einer Erstellen einer neuen Zeichnung Applikationen zu laden.

    Jedes mal wenn AutoCAD eine Zeichnung öffnet, wird der Support-Suchpfad nach der Datei ACADDOC.LSP Datei durchsucht. Wenn diese Datei gefunden wird, wird diese Datei in den Speicher geladen und gegebenenfalls Funktionen in dieser Datei ausgeführt. Die ACADDOC.LSP wird JEDESMAL beim Öffnen einer Zeichnung geladen, unabhängig der Einstellung der Systemvarible ACADLSPASDOC.

    Die meisten nutzen eine ACADDOC.LSP für alle Zeichnungen. AutoCAD sucht in den Optionen definierten Support Such-Pfaden nach dieser Datei. Wenn diese im Dokumentenpfad gespeichert wurde, können mehrere unterschiedliche ACADDOC.LSP Dateien genutzt werden, um Applikationen abhängig der Zeichnungs-Typen zu laden.

    Die ACADDOC.LSP kann Funktionen - definiert durch

    (defun ....)

    oder weitere

    (LOAD ...)

    Funktionen beinhaltet.

    WARNUNG

    Bitte die reservierte Datei ACAD[Version]DOC.LSP nicht verändern. Autodesk nutzt diese Datei, sie enthält in AutoLISP definierte Funktionen, die von AutoCAD benutzt werden. Diese Datei wird unmittelbar vorm Laden der ACADDOC.LSP geladen.

    Beschreibung der Systemvariable: ACADLSPASDOC (Zitat aus der Hilfe)

    Legt fest, ob die Datei acad.lsp in jede Zeichnung geladen werden soll oder nur in die Zeichnung, die in einer Sitzung jeweils zuerst geöffnet wird.

    0 Lädt die Datei acad.lsp nur in die erste Zeichnung, die in einer Sitzung geöffnet wird.
    1 Lädt die Datei acad.lsp in jede geöffnete Zeichnung.

    Die ACAD.LSP Datei

    Wenn AutoCAD startet, sucht AutoCAD in den Optionen im Register “Dateien” definierten Support-Such Pfad nach der Datei ACAD.LSP. Wird die Datei gefunden, wird sie in den Speicher geladen.

    Die ACAD.LSP Datei wird JEDESMAL geladen wenn eine Zeichungs-Session gestartet wird. Da die ACAD.LSP nur für Routinen, die beim Starten von AutoCAD genutzt werden, genutzt wird, stehen die Funktionen und Variblen nur der ersten Zeichnung zur Verfügung. Werden die Funktionen und Variablen in allen Zeichnungen benötigt, müssen diese in der ACADDOC.LSP integriert werden. Wird die Systemvariable ACADLSPASDOC auf 1 gesetzt, können die Funktionen aus der ACADDOC.LSP auch in der ACAD.LSP integriert werden, denn dann wird die ACAD.LSP bei jeder Zeichnung geladen.

    Auch hier können Ladefunktionen integriert werden.

    Ihr Jürgen A. Becker

    Veröffentlicht in DotNet-Programmierung mit C#, Visual-Basic for Application, Visual-Lisp | Keine Kommentare »

    Visual LISP: Speichern eigener Daten in die Zeichnung, Teil 2 -

    Montag, 3. August 2009

    In diesem Artikel sollen Daten in ein Dictionary der aktuellen Zeichnung geschrieben werden.

    Die dazu benötigten Visual-LISP-Funktionen lauten:
    Speichern von Werten in ein Dictionary

    (vlax-ldata-put [Dictionary] [Key] [Data] [privat])

    Beispiel:

    (vlax-ldata-put "PData" "ProjectNumber" "4711")

    Dieses Beispiel speichert die Projektnummer 4711 in das Dictionary ProjectData.

    Lesen von Werten aus einen Dictionary

    (vlax-ldata-get [Dictionary] [Key])

    Beispiel:

    (vlax-ldata-get "PData" "ProjectNumber")

    Die Funktion:

    (vlax-ldata-list [Dictionary]])

    listet alle Dictionary-Einträge auf.

    Beispiel:
    Zuvor wurden einem Objekt die Daten der Nennweite und der Durchflussmenge angehängt. Mit der Funktion:

    (vlax-ldata-list (car (entsel)))

    werden alle Daten eines Objekt-Dictionaries in Form einer Liste ausgegeben.

    ((”Nennweite” . “DN 50″) (”Durchflussmenge” . “100.0″))

    Bei allen diesen Funktionen kann nicht nur ein Dictionary der aktuellen Zeichnung, sondern auch ein VLA-Objekt oder ein AutoCAD-Objekt angesprochen werden.
    Somit können benutzerdefinierte Daten an Objekte der Zeichnung gehängt werden.

    Beispiel:
    Im folgenden Beispiel wird die Wasser-Durchflussmenge in Höhe von 100.0 an ein AutoCAD-Objekt (z.B. eine Linie) gehängt.

    (vlax-ldata-put (car (entsel)) "Durchflussmenge" 100.0)

    Die Objektdaten dieser Linie sehen nun wie folgt aus.
    Aufruf mit:

    (setq E (entget (car (entsel))))

    ((-1 . <Objektname: 7e40c378> )
    (0 . “LINE”)
    (5 . “3BF”)
    (102 . “{ACAD_XDICTIONARY”)
    (360 . <Objektname: 7e40c380>)
    (102 . “}”)
    (330 . <Objektname: 7e5f1cf8>)
    (100 . “AcDbEntity”)
    (67 . 0)
    (410 . “Model”)
    (8 . “0″)
    (100 . “AcDbLine”)
    (10 1547.29 1074.73 0.0)
    (11 2112.46 1819.34 0.0)
    (210 0.0 0.0 1.0))

    Der Gruppencode 360 hinter ACAD_XDICTIONARY beinhaltet die von uns gespeicherten Daten.
    Diese können wir nicht nur per (vlax-ldata-get …) auslesen, sondern auch mit

    (entget (cdr (Assoc 360 (entget (car (entsel))))))

    ((-1 . )
    (0 . “DICTIONARY”)
    (330 . <Objektname:7e40c378>)
    (5 . “3C0″)
    (100 . “AcDbDictionary”)
    (280 . 1)
    (281 . 1)
    (3 . “Durchflussmenge”)
    (360 . <Objektname: 7e40c388>))

    Hinter den Gruppencode 360 versteckt sich der Wert des Durchflusses.

    ((-1 . <Objektname: 7e40c388> )
    (0 . “VLO-VL”)
    (5 . “3C1″)
    (102 . “{ACAD_REACTORS”)
    (330 . <Objektname: 7e40c380>)
    (102 . “}”)
    (330 . <Objektname: 7e40c380>)
    (100 . “vlo_VL”)
    (90 . -64512)
    (91 . 7)
    (92 . 0)
    (300 . “\”100.0\”"))

    Mit diesen Funktionen können sowohl Objekten, als auch der Zeichnung benutzerdefinierte Daten angehängt werden, so dass man nicht mehr nur auf von Autodesk vordefinierte Eigenschaften angewiesen ist.

    Viel Spaß beim Ausprobieren

    Autor: Dipl.-Ing. Jürgen A. Becker
    Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

    • Veröffentlicht in Visual-Lisp | 1 Kommentar »

    Visual LISP: Speichern eigener Daten in die Zeichnung -

    Mittwoch, 29. Juli 2009

    Häufig ist es wichtig eigene Daten in Form von Systemvariablen in die Zeichnung zu speichern, damit diese beim späteren Aufruf der Zeichnung wieder zur Verfügung stehen.

    Zur Realisation hat Autodesk hat mehrere Möglichkeiten zur Verfügung gestellt:

    Systemvariablen

    Nutzung der Systemvariablen “useri0-4″, “userr0-4″ und “users0-4″.

    Die Systemvariablen “users0-4″ stehen nur während der aktuellen Arbeit an dieser Zeichnung zur Verfügung. Sie werden nicht gespeichert, so dass sie beim späteren Aufruf NICHT zur Verfügung stehen.

    ;der Daten in die Systemvariable "Userr0"
    (setvar "userr0" 2.0)
    ;Auslesen der Systemvariable "Userr0"
    ;und Speichern in die Variable hBreite
    (setq hBreite (getvar "Userr0"))

    Übergabe von Daten in andere geöffnete Zeichnungen

    Da die Lisp-Funktionen und deren Daten im eigenen Namepace der Zeichnung gespeichert werden, stehen diese in anderen geöffneten Zeichnung nicht zur Verfügung.

    Um Daten von einer geöffneten Zeichnung in eine andere zu übergeben sollte das Blackboard Namespace genutzt werden. Dazu stellt Visual LISP eine Funktion zur Verfügung

    Speichern der Daten in das Blackboard Namespace

    (vl-bb-set 'symbol value)

    Auslesen der Daten aus dem Blackboard Namespace

    (vl-bb-ref 'variable)

    Aufbau einer eigenen Applikations-Systemvaribalen Bibliothek

    Eine sehr schöne Möglichkeit, um eigene nicht grafische Daten in der Zeichnung abzulegen, ist die Nutzung des Dictionaries.
    Nach Anlegen eines Applikations-Dictionaries können dort Daten aller Art abgelegt werden.
    Diese Möglichkeit ist sehr komplex und umfangreich. In den nächsten Artikeln dieses Blogs wird die Nutzung eines Applkations-Dictionary erläutert.

    Hier geht es weiter mit Teil 2.

    Viel Spaß beim Ausprobieren

    Autor: Dipl.-Ing. Jürgen A. Becker
    Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

  • Langjährige Schulungserfahrung
  • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
  • Software- und Datenbankentwicklung

    • Veröffentlicht in Visual-Lisp | 1 Kommentar »

    AutoLISP Crash Course auf der Autodesk University: Ein Video

    Mittwoch, 29. Juli 2009
    Wer sich mit AutoLISP oder Visual Lisp im AutoCAD beschäftigen möchte, ist dieses Video empfohlen.
    Über das CAD-Newsportal CADRelations können sich diejenigen, die sich bei der AU anmelden bzw. registrieren dieses Video anschauen. 

    AutoLisp Crash Course

    AutoLisp Crash Course

    Das Handout und der Podcast des Seminars stehen kostenfrei zum Download zur Verfügung.
    Inhalt:
    • Automatisches Laden einer Lisp-Routine
    • Aufbau einer Lisp-Funktion
    • Definition einer Lisp-Funktion
    • Variablen-Definitionen
    • Aufruf von AutoCAD-Befehlen
    • AutoCAD-Befehle umdefinieren uvm.

    Viel Spaß beim Anschauen.

    Ihr Jürgen A. Becker

    Veröffentlicht in Visual-Lisp | Keine Kommentare »

    AutoCAD 2009 - MoveBAK: Ein Express-Tool selber programmiert -

    Samstag, 31. Januar 2009

    Mit dem Express-Tool “MOVEBAK” kann ein separater Ordner für die Backup-Dateien (*.BAK) der Zeichnungen angegeben werden. Im Normalfall werden diese Dateien im Zeichnungsordner - im selben Ordner wie die DWG’s - gespeichert. die Optionen lassen ein Ändern des Backup-Ordners nicht zu.

    Hier ein Beispiel, das diese Funktion in Visual-Lisp vorstellt.

    (defun c:MoveBak ( / )
    (vl-load-com)
    ;Der AutoCAD - Produktkey wird ermittelt
    (setq currentacad (vlax-product-key))

    ;Der Gerneral-Schlüssel wird ermittelt
    (setq hGeneralKey
       (strcat
         "HKEY_CURRENT_USER\\"
         currentacad
         "//fixedprofile//General\\FixedProfile\\General"))

    ;Der aktuelle Ordner der BAK-dateien wird ermittelt
    (setq hCurrentBAKPath
        (vl-registry-read hGeneralKey "AcetMoveBak" ))
    (if (/= hCurrentBAKPath nil)
    ;Eingabe des neuen BAK-Ordners
    (if (/= hCurrentBAKPath "")
    (setq hAnfrageText
        (strcat "\nNeuer BAK-Ordner eingeben &lt;"
                  hCurrentBAKPath
                  "&gt;: "))
    (setq hAnfrageText "\nNeuer BAK-Ordner eingeben: ")
    );end if
    (setq hAnfrageText "\nNeuer BAK-Ordner eingeben: ")
    );end if

    (setq hKeyValue (getstring hAnfrageText))

    ;ist eine Eingabe erfolgt und
    ;wird der alte Wert überschrieben,
    ;wird der neue BAK-Ordner in
    ;die Registry geschrieben
    (if (/= hKeyValue "")
    (progn
    (if (not
          (setq hError
            (vl-registry-write
                    hGeneralKey
                    "AcetMoveBak"
                    hKeyValue)))
    (alert "Funktion ist fehlgeschlagen")
    );end if
    );end progn
    );end if
    (princ)
    )

    Viel Spaß beim Ausprobieren.

    Autor: Dipl.-Ing. Jürgen A. Becker
    Kontakt: Juergen.Becker@CAD-Becker.de oder Juergen.Becker@AUGI.COM

    • Langjährige Schulungserfahrung
    • Autorisierter AutoCAD Trainer (AutoCAD, Mechanical Desktop etc.)
    • Software- und Datenbankentwicklung

     

     

     

     

     

     

    Veröffentlicht in Visual-Lisp | 2 Kommentare »

    AutoCAD 2009 - Eine Anwendung eines Visual-Lisp Projektes erstellen -

    Samstag, 31. Januar 2009

    Anwendung erstellen
    In vielen Fällen sollen die Sourcen einer LISP-Anwendung nicht sichtbar sein. Der Visual-Lisp Editor bietet mit „Erstellen einer Anwendung“ mit Hilfe des Anwendungs-Assistenten die Möglichkeit LISP-Programme zu kompilieren. Diese Dateien mit der Endung .VLX können nicht mehr eingesehen werden und laufen in der Regel schneller ab.

    Starten des Anwendungs-Assistenten

    Aufruf des Anwendungs-Assistenten

    Der Anwendungs-Assistent wird gestartet.

    Auswahl des Assistenten-Modus

    Auswahl des Modus

    Werden nur LISP-Datei kompiliert, reicht der einfache Modus, werden .DCL oder .DVB-Datei benötigt, muss der erweiterte Modus ausgewählt werden.

    Auswahl des Anwendungsverzeichnis und Auswahl des Anwendungsnamens

    Festlegung des Anwendung-verzeichnisses

    Der Anwendungsname ist der Dateiname der kompilierten LISP-Dateien. Diese Datei erhält die Endung .VLX.

    Auswahl der Dateien, die in die Anwendung kompiliert werden sollen

    Hinzufügen

    		 Auswahl der zugehörigen Dateien.
    Entfernen
    		 Hinzugefügte Dateien werden entfernt
    Oben/ Unten
    		 Die Reihenfolge der zugehörigen Dateien wird verändert
    Nach oben/ nach unten Die Reihenfolge der zugehörigen Dateien wird verändert

    Quelldateien auswählen

    Fertigstellen der Anwendung

    Anwendung fertig erstellen

    Mit Fertigstellung entsteht eine kompilierte Version der Anwendung mit allen zugehörigen Dateien.

    Laden der Anwendung

    Diese Anwendung kann im AutoCAD mit dem Befehl APPLOAD geladen werden.

    Laden einer Anwendung

    (more…)

    Veröffentlicht in Visual-Lisp | 1 Kommentar »