Startseite

Über Jürgen A. Becker

Impressum

CAD-Dienstleistungen

Schulungsangebot

Archiv für August 2009

.Net-Framework - Layer, Stile, Linientype und Blöcke -

Samstag, 29. August 2009

Layer, Stile z.B. Bemaßungs- und Textstile, Linientypen und Blöcke etc. sind in Tabellen in der Zeichnung gespeichert.

Diese können in C# oder VB.Net ausgelesen und die TableRecord (der einzelne Layer oder Linientyp) bearbeitet werden.

Die Klassen dieser Tabellen gehören zum Namespace

Autodesk.AutoCAD.DatabaseServices.

und heißen wie folgt:

Hier ein Bespiel zur Deklaration der Variablen

private LayerTable hLayerTable;
private LinetypeTable hLineTypeTable;
private DimStyleTable hDimStyle;
private TextStyleTable hTextStyleTable;

Die einzelnen Layer, Stile und Linientypen etc. werden in TableRecords gespeichert.

Die Klassen dieser Records gehören ebenfalls zum Namespace

Autodesk.AutoCAD.DatabaseServices.

und lauten wie folgt:

private LinetypeTableRecord hLineType;
private LayerTableRecord hLayer;
private TextStyleTableRecord hTextStyle;

Hier ein kleines Beispiel zum Auflisten der Layernamen.

using System;
using System.Collections.Generic;

#region Usings für AutoCAD
    using Autodesk.AutoCAD;
    using Autodesk.AutoCAD.Runtime;
    using AcAp = Autodesk.AutoCAD.ApplicationServices;
    using AcDB = Autodesk.AutoCAD.DatabaseServices;
    using AcEd = Autodesk.AutoCAD.EditorInput;
#endregion

namespace AcadUtilty
{
  public class clsAcadTables
  {
     Document doc =
        AcAp.Application.DocumentManager.MdiActiveDocument;
     Editor ed = doc.Editor;
     Database hDB = doc.Database;
     Transaction hTr = hDB.TransactionManager.StartTransaction();
     using (hTr)
     {
        try
        {    
          hLayerTable =
           (LayerTable)hTr.GetObject(hDB.LayerTableId, OpenMode.ForRead);
          //Die Layer-Tabelle wird ausgelesen
         foreach (ObjectId hObId in hLayerTableTemplate)
         {
            LayerTableRecord hLayer =
               (LayerTableRecord)hTr.GetObject(hObId, OpenMode.ForRead);
            string hMessage = "\nLayername" + hLayer.Name;
            ed.WriteMessage(hMessage);
         }  
         catch (Autodesk.AutoCAD.Runtime.Exception e)
         {
            string hMessage = "\n" + e.Message;
            ed.WriteMessage(hMessage);
         }
         finally
         {
           hTr.Commit();
         }
      }
   }
}

Sollen TableRecords geändert werden, muss die Tabelle schreibend geöffnet werden. Im obigen Bespiel ist sie lesend geöffnet, da nur Informationen herausgelesen werden sollen.

//Lesend geöffnet
hLayerTable =
  (LayerTable)hTr.GetObject(hDB.LayerTableId, OpenMode.ForRead);

//Schreibend geöffnet
hLayerTable =
  (LayerTable)hTr.GetObject(hDB.LayerTableId, OpenMode.ForWrite);

Bei Änderungen an der Tabelle oder den Records dieser Tabelle, darf ein Commit des Transactions nicht vergessen werden, ansonsten finden keine Änderungen in der Zeichnung statt.

Die Bearbeitung der Tabelle und der Records findet in einem try-Block statt, um Exception in einem catch-Block abfangen zu können. Im finally-Block werden die Änderungen die innerhalb des Transactions durchgeführt wurden mit der Methode Commit() abgeschlossen.

try
 {    

 }  
catch (Autodesk.AutoCAD.Runtime.Exception e)
 {
   string hMessage = "\n" + e.Message;
   ed.WriteMessage(hMessage);
 }
finally
 {
   hTr.Commit();
 }

Sollen gezielt TableRecords angesprochen werden, wird über den Key - normalerweise der Name z.B. Layername dieses Records - dieser Record erstellt. Wir erhalten eine ObjectId über die wir mit Hilfe der Methode GetObject der Transaction das Objekt erhalten.

Im folgenden Beispiel wird der Layer “A_Wand” ausgelesen. Man sollte beachten, dass dieser Layer existieren muss.

ObjectId hLayerID = (ObjectId)hLayerTable["A_Wand"];
LayerTableRecord hLayer =
     (LayerTableRecord)hTr.GetObject(hLayerID, OpenMode.ForWrite);

Eine Überprüfung auf Vorhandensein eines Records erfolgt über die Methode Has der Tabelle.

if (hLayerTable.Has("A_Wand") == false)
{
  //Mach etwas, vielleicht den Layer erstellen
}

Alle anderen Tabellen werden analog ausgelesen.

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

.Net-Framework: Optimierung der Initialisierung der eigenen .Net-Applikation

Montag, 24. August 2009

Zum Initialisieren der eigenen Applikation wird eine Initialize()-Methode implementiert, in der wichtige Einstellungen der Applikation z.B. System-Variablen etc. gesetzt werden. Diese Methode wird vom AutoCAD beim Laden der Applikation aufgerufen und ausgeführt.

Die Terminate()-Methode wird beim Schließen von AutoCAD aufgerufen und sollte Dinge enthalten, die beim Schließen der Applikation ausgeführt werden müssen z.B. Schließen einer Datenbankverbindung.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Autodesk;
using Autodesk.AutoCAD.Runtime;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.DatabaseServices;
using Autodesk.AutoCAD.EditorInput;

[assembly: ExtensionApplication(typeof(ACADTest.clsACADTest))]
[assembly: CommandClass(typeof(ACADTest.CmdClass))]

namespace ACADTest
{
   
    public class clsACADTest : IExtensionApplication
    {
        public void Initialize()
        {
            //Ausführung beim Laden
        }

        public void Terminate()
        {
            //Ausführung beim Schließen
        }
    }
    public class CmdClass
    {
        [Autodesk.AutoCAD.Runtime.CommandMethod("SagHallo")]
        public static void SagHallo()
        {
            Application.ShowAlertDialog("Hallo");
        }
    }
}

AutoCAD wird in der .Net-Applikation nach diesen Methoden suchen, werden sie gefunden, werden sie entsprechend behandelt. Bei einer hohen Anzahl von Klassen in der Applikation, kann das zu einer Verzögerung führen.

Dieser Ladenvorgang von eigenen .Net-Applikationen kann optimiert werden, indem AutoCAD mitgeteilt wird, in welcher Klasse sich diese Methoden befiinden. Dieses geschieht durch das Einfügen des ExtensionApplication-Attributs. Die Initialisierung und Terminate-Klasse muss ebenfalls das Interface IExtensionApplication erben.

[assembly: ExtensionApplication(typeof(ACADTest.clsACADTest))]

Das CommandClass-Attribut zeigt AutoCAD an, in welcher Klasse sich die programmierten neuen Befehle der Applikation befinden.

[assembly: CommandClass(typeof(ACADTest.CmdClass))]

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

.Net-Framework: Debugging-Einstellungen

Montag, 24. August 2009

Um Programme zu testen werden die Debugging-Funktionalitäten der Entwicklungsumgebung genutzt. Dieses funktioniert wunderbar bei eigenständigen Programmen - die nicht im AutoCAD aufgerufen werden -. Sollen Programme, die im Umfeld von AutoCAD lauffähig sind, ist dieses etwas komplizierter.
Hier die Einstellungen im Visual Studio 2008, die dazu notwendig sind (bei der Express-Edition können diese Einstellungen nicht vorgenommen werden):

In den Eigenschaften des Projektes wird im Register “Debuggen” ein “externes Programm” definiert, dieses ist die ACAD.EXE aus dem Installationspfad vom AutoCAD.

Für die Verweise acdbmgd.dll und acmgd.dll muss die Eigenschaft “lokale Kopie” auf false gestellt werden.

Wird der Debugger im Visual Studio gestartet, startet AutoCAD.

Im AutoCAD mit dem Befehl NETLOAD die DLL laden und die gewünschten Befehle ausführen. Werden Haltepunkte gesetzt, hält die Ausführung des Programms an dieser Stelle an. Die Überprüfung kann nun beginnen.

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

.Net-Framework: Eine kleine Einführung

Freitag, 21. August 2009


Programmiersprachen im AutoCAD

AutoCAD ist seit seiner ersten Version individuell programmierbar. Als allererste Programmiersprache stand AutoLISP (heute Visual Lisp) zur Verfügung. Danach folgten C, C++ und mit späteren Versionen Visual-Basic for Application (VBA). Ab der AutoCAD Version 2004 und ab Inventor 11 hat Autodesk die Möglichkeit geschaffen .Net-Anwendungen zu integrieren.

Welche Programmsprache der Einzelne nutzt, ist eine individuelle Vorliebe. Da C oder C++ nun wirklich nicht jedermanns Sache ist, wird häufig auf Visual-Lisp oder VBA zurückgegriffen. Diese beide Programmiersprachen entsprechen allerdings nicht unbedingt der objektorientierten Denkweise. Hier möchte ich die „neue“ Möglichkeit – Nutzung des .Net-Frameworks – vorstellen. Denjenigen, der schon häufig mit VBA programmiert hat, wird leicht auf VB.NET umsteigen können, denn die Syntax ist sehr ähnlich. Ist dieser Schritt gemacht, kann auch schnell auf C# umgestiegen werden, denn auch hier ist die Syntax ähnlich. Man sollte keine Angst vor dem kleinen Buchstaben C haben. Stürzen wir uns doch einfach ins Geschehen.

Werkzeuge

Natürlich benötigt man, wie bei jeder anderen Programmiersprache auch, Werkzeuge, die uns das Erstellen der Programme ermöglicht.
Ich möchte hier zwei gängige Entwicklungsumgebungen vorstellen, die ich in meiner Arbeit selber nutze. Diese Entwicklungsumgebungen sind frei verfügbar, somit kostenlos.

Verweise

Um das AutoCAD im eigenen Programm anzusprechen benötigen wir Verweise auf das AutoCAD-Objektmodell. Diese DLL’s befinden sich im Installationspfad vom AutoCAD.

  • AutoCAD .NET Managed Wrapper (acmgd.dll)
  • ObjectDBX .NET Managed Wrapper (acdbmgd.dll)

Beispiel: HalloWelt

using System;
using System.Windows.Forms;
using Autodesk.AutoCAD.ApplicationServices;
using Autodesk.AutoCAD.EditorInput;
using Autodesk.AutoCAD.Runtime;

namespace clsACAD
{
  public class clsHalloWelt
  {
    string hText = "Hallo Welt";
    public clsHalloWelt()
   {
   }

   [CommandMethod("HalloWelt")]
   public void HalloWelt()
   {
     Autodesk.AutoCAD.EditorInput.Editor ed =
       Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument.Editor;
       ed.WriteMessage(hText);
       //Alternativ
       //System.Windows.Forms.MessageBox.Show(hText);
    }
  }
}

Im nächsten Blog-Beitrag werde ich über Eingabe- und Ausgabemöglichkeiten schreiben.

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

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

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

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
  • 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

    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