Migrating AutoLISP Programs that Previously Used the IAcadFileDependencies and IAcadFileDependency Classes

Starting with AutoCAD 2018-based products, AutoLISP programs that utilize the members defined by the IAcadFileDependencies and IAcadFileDependency classes in the AutoCAD ActiveX/COM library must be updated as a result of the classes being removed. The AutoLISP functions that are affected are:

  • Methods
    • vla-CreateEntry
    • vla-IndexOf
    • vla-Item
    • vla-RemoveEntry
    • vla-UpdateEntry
  • Properties
    • vla-get-AffectsGraphics
    • vla-get-Count
    • vla-get-Feature
    • vla-get-FileDependencies
    • vla-get-FileName
    • vla-get-FileSize
    • vla-get-FingerprintGuid
    • vla-get-FoundPath
    • vla-get-FullFileName
    • vla-get-Index
    • vla-get-IsModified
    • vla-get-ReferenceCount
    • vla-get-TimeStamp
    • vla-get-VersionGuid

The IAcadFileDependencies and IAcadFileDependency classes were useful in obtaining information about the files attached to or referenced by a drawing file, such as xrefs, fonts, and plot styles.  However, those classes didn't always work consistently as expected and didn't support all files that could be attached to or referenced by a drawing, such as Coordination Models, weblight IES definition files, images used to define materials for rendering and more.  Even with the short comings of the two classes and their members, they were useful.

This article doesn't focus on how to go about reintroducing all of the functionality that the two classes supported, but focuses on how to go about getting the file paths to the files attached to or referenced by a drawing.  The filename and path information associated with an attached or referenced file can be found in a few different places within the drawing database, it is a matter of knowing where to look.  Filenames/paths to a file referenced by a drawing is stored in one of the following places:

  • Properties of objects stored in a symbol table; xrefs and font styles
  • Data of an xrecord attached to a named dictionary; underlays and materials
  • Data of an xrecord attached to an extension dictionary; weblight (IES) definition files

Note: The code samples in this article are provided AS-IS and may need to be modified to handle conditions that were not identified during development.

The following code sample is a utility function that splits a string into individual elements based on a specified character, and returns the individual string elements as a list.  The SPLIT function is used by several of the sample function to split the path of support folders:

;; Usage: (split (getenv "PrinterConfigDir") ";")
;; Usage: (split (getenv "PrinterStyleSheetDir") ";")
(defun split (sExpression sDelimiter / len val sList)
  ; Get the length of the first item from the expression based on delimiter position
  (setq len (vl-string-position (ascii sDelimiter) sExpression))

  ; Loop until there are no more instances of the delimiter in the expression
  (while (numberp len)
    ; Get the item from the expression
    (setq val (substr sExpression 1 len))

    ; Append the item to the list
    (setq sList (cons val sList))

    ; Get the remaining part of the expression
    (setq sExpression (substr sExpression (+ 2 len)))

    ; Get the length of the next item from the string based on delimiter position
    (setq len (vl-string-position (ascii sDelimiter) sExpression))
  )

  ; Add the last value to the list
  (if (/= sExpression nil)
    (setq sList (cons sExpression sList))
  )

  ; Reverse the elements and return the list
  (reverse sList)
)

The SPLIT function was originally mention in the article "Splitting A String Into A List of Elements Based on Delimiter".

The following is yet another utility function that was written, and it attempts at trying to resolve relative paths. The RESOLVERELATIVEPATH function accepts two string arguments, the first is a file name with a path and the second is the path to try and resolve the relative path with.  The resolve path will commonly be the location of the drawing file.

;; Returns a filename based on the resolved path
;; Usage: (ResolveRelativePath "..\\grid.dwg" (getvar "dwgprefix"))
(defun ResolveRelativePath (fileNamePath dwgPath / )
  ; Check for relative paths and attempt to resolve the path to the xref
  (cond
    ; Relative path, should resolve multiple levels of relative folders; DWG file must be saved
    ((and (= (substr fileNamePath 1 2) "..")(/= (getvar "dwgprefix") ""))
      (while (= (substr fileNamePath 1 2) "..")
        (setq fileNamePath (substr fileNamePath 4)
              dwgPath (substr dwgPath 1 (vl-string-position (ascii "\\") dwgPath 0 T))
        )
      )
      (setq fileNamePath (strcat dwgPath "\\" fileNamePath))
    )
    ; Absolute paths, resolves only the top level folder; DWG file must be saved
    ((and (= (substr fileNamePath 1 1) ".")(/= (getvar "dwgprefix") ""))
      (setq fileNamePath (substr fileNamePath 3)
            fileNamePath (strcat dwgPath "\\" fileNamePath)
      )
    )
  )
 
  ; Check to see if the fileNamePath is valid, if not then attempt to locate the file in the working support path
  (if (not (findfile fileNamePath))
    (setq fileNamePath (findfile (strcat (vl-filename-base fileNamePath) (vl-filename-extension fileNamePath))))
    (if (= (vl-filename-directory fileNamePath) "")
      (setq fileNamePath (findfile fileNamePath))
    )
  )

  ; Returns the resolved path with filename, if the path couldn't be resolved
  ; then the original fileNamePath is returned
  fileNamePath
)

Now that the two utility functions have been defined, the heart of the sample functions are used to return the filenames and paths for these types of attached or referenced files:

  • Xrefs - Named objects are stored in the Block symbol table; they are blocks with a filename and path information
  • Raster images - Definitions are stored in the ACAD_IMAGE_DICT named dictionary
  • Fonts - References to SHX and TTF files associated with text styles stored in the Style symbol table
  • DWF Underlays - Definitions are stored in the ACAD_DWFDEFINITIONS named dictionary; DWF and DWFx files
  • DGN Underlays - Definitions are stored in the ACAD_DWFDEFINITIONS named dictionary; DGN files
  • PDF Underlays - Definitions are stored in the ACAD_PDFDEFINITIONS named dictionary; PDF files
  • Point clouds - Definitions are stored in the ACAD_POINTCLOUD_EX_DICT named dictionary; RCP files
  • Coordination models - Definitions are stored in the ACAD_BIM_DEFINITIONS named dictionary; NWC and NWD files
  • Weblight configuration - Information is attached to a LIGHT entity as an extension dictionary with the name ADSK_XREC_PHOTOMETRICLIGHTINFO
  • Materials - Definitions are stored in the ACAD_MATERIAL named dictionary
  • Plot styles and configurations - References to PC3, CTB, and STB files are stored in the ACAD_LAYOUT and ACAD_PLOTSETTINGS named dictionaries
  • Sheet sets - Information related to the layout associated with a sheet set is stored in the AcSheetSetData named dictionary

The functions defined by the following AutoLISP code samples are:

  • XrefPathsList - Returns a list of the drawing (DWG) files attached to the drawing
  • RasterImagePathsList - Returns a list of the raster images attached to the drawing
  • TextFontPathsList - Returns a list of the font files associated with text styles defined in the drawing
  • WebLightPathsList - Returns a list of the IES files associated with LIGHT entities defined in Model Space and other block definitions
  • MaterialImagePathsList - Returns a list of the image files associated with the materials defined in the drawing
  • PlotSettingsList - Function used by the PlotConfigurationPathsList and PlotStylesPathsList functions
    • PlotConfigurationPathsList - Returns a list of PC3 files assigned to the page setups/plot settings in the drawing
    • PlotStylesPathsList - Returns a list of STB or CTB files assigned to the page setups/plot settings in the drawing
  • UnderlaysList - Function used by the DWFUnderlaysPathsList, DGNUnderlaysPathsList, PDFUnderlaysPathsList, PointCloudsPathsList, and CoordinationModelPathsList functions
    • DWFUnderlaysPathsList - Returns a list of DWF/DWFx files referenced by the drawing
    • DGNUnderlaysPathsList - Returns a list of DGN files referenced by the drawing
    • PDFUnderlaysPathsList - Returns a list of PDF files referenced by the drawing
    • PointCloudsPathsList - Returns a list of RCP files referenced by the drawing
    • CoordinationModelPathsList - Returns a list of NWC and NWD files referenced by the drawing
  • AssociatedDSTPathList - Returns the DST file which the drawing/layout is referenced

;; Returns a list of Xref filenames attached to the drawing
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (XrefPathsList T)
;; Usage: (XrefPathsList nil)
(defun XrefPathsList (bIncludeFullPath / ent val fullName fileName fileList)
  ; Get the first element of the Blocks symbol table
  (setq ent (tblnext "block" T))

  ; Step through the Blocks symbol table
  (while ent
    ; Check for the DXF group code 1
    (if (setq val (assoc 1 ent))
      (progn
        ; Get the xref path name from the DXF group
        (setq fullName (cdr val))

        ; Determine whether the filename is returned only or the full path
        (if bIncludeFullPath
          (progn
            ; Check for a relative path and attempt to resolve the path
            (setq fileName (ResolveRelativePath fullName (vl-string-trim "\\" (getvar "dwgprefix"))))
          )
          ; Return the filename and extension only
          (setq fileName (strcat (vl-filename-base fullName) (vl-filename-extension fullName)))
        )

        ; Append the filename to the list
        (setq fileList (cons fileName fileList))
      )
    )

    ; Return the next block in the Block symbol table
    (setq ent (tblnext "block"))
  )

  ; Return a sorted list of filenames
  (vl-sort fileList '<)
)

;; Returns a list of Raster Image filenames attached to the drawing
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (RasterImagePathsList T)
;; Usage: (RasterImagePathsList nil)
(defun RasterImagePathsList (bIncludeFullPath / imageDict cnt val fileName fullName fileList)
  ; Step through the definitions in the attached images dictionary
  (foreach val (setq imageDict (dictsearch (namedobjdict) "ACAD_IMAGE_DICT"))

    ; Check for the DXF group code 350, dictionary entry
    (if (= (car val) 350)
      (progn
        ; Get the name/path of the image
        (setq fullName (cdr (assoc 1 (entget (cdr val)))))

        ; Determine whether the filename is returned only or the full path
        (if bIncludeFullPath
          ; Get and attempt to resolve the relative path as needed
          (setq fileName (ResolveRelativePath fullName (vl-string-trim "\\" (getvar "dwgprefix"))))

          ; Get the filename and extension only
          (setq fileName (strcat (vl-filename-base fullName) (vl-filename-extension fullName)))
        )

        ; Append the filename to the list
        (setq fileList (cons fileName fileList))
      )
    )
  )

  ; Return a sorted list of filenames
  (vl-sort fileList '<)
)

;; Returns a list of Text Font filenames used by the text styles defined in the drawing
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; bIncludeXrefs = T - Include text styles from Xrefs
;; bIncludeXrefs = nil - Exclude text styles from Xrefs
;; Usage: (TextFontPathsList T nil)
;; Usage: (TextFontPathsList nil T)
(defun TextFontPathsList (bIncludeFullPath bIncludeXrefs / ent fullName fileName fileList)
  ; Get the first text syle in the Style symbol table
  (setq ent (tblnext "style" T))

  ; Step through the Style symbol table
  (while ent
    ; Determine if text styles from xrefs should be included in the file list
    (if (or (= bIncludeXrefs T)
     (and (not (wcmatch (cdr (assoc 2 ent)) "*[|]*")) (= bIncludeXrefs nil)))
      (progn
        ; Get the name/path of the font file
        (setq fullName (cdr (assoc 3 ent)))

        ; Check to see if there is a file extension, if not it is a SHX file
        (if (= (vl-filename-extension fullName) nil)
          (setq fullName (strcat fullName ".shx"))
        )

        ; Determine the current OS: Windows or Mac
        (if (wcmatch (strcase (getvar "platform")) "*WINDOWS*")
          (if (findfile (strcat (getenv "WINDIR") "\\fonts\\" fullName))
            (setq fullName (strcat (getenv "WINDIR") "\\fonts\\" fullName))
            (setq fullName (findfile fullName))
          )
          ; Mac OS currently not supported - (wcmatch (strcase (getvar "platform")) "*MAC*")
          (setq fullName "")
        )

        ; Determine whether the filename is returned only or the full path
        (if bIncludeFullPath
          ; Get the full filename
          (setq fileName fullName)

          ; Get the filename and extension only
          (setq fileName (strcat (vl-filename-base fullName) (vl-filename-extension fullName)))
        )

        ; Check to see if the entry already exists in the list
        (if (not (member fileName fileList))
          (setq fileList (cons fileName fileList))
        )
      )
    )

    ; Return the next text style in the Style symbol table
    (setq ent (tblnext "style"))
  )

  ; Return a sorted list of filenames
  (vl-sort fileList '<)
)

;; Returns a list of Weblight filenames based on the Web lights in all block definitions
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (WebLightPathsList T)
;; Usage: (WebLightPathsList nil)
(defun WebLightPathsList (bIncludeFullPath / blkName entBlkSym entName entData xDict fileList)
  ; Get the first element of the Blocks symbol table
  (setq blkName "*MODEL_SPACE")
  (setq entBlkSym (tblobjname "BLOCK" blkName)) ;;(tblnext "block" T))

  ; Step through the Blocks symbol table
  (while entBlkSym
    ; Get the entity name for the block definition and its data
    (setq entName (tblobjname "BLOCK" blkName)
          entData (entget entName))

    ; Step through each object in the block definition
    (while entName
      (if (/= entName nil)
        (progn
          ; Check to see if the entity is a Light object
          (if (= (strcase (cdr (assoc 0 entData))) "LIGHT")
            ; Check for the DXF group code 360, an extension dictionary
            (if (assoc 360 entData)
              ; Check for and get the extension dictionary related to the Photometric Light information
              (if (setq xDict (dictsearch (cdr (assoc 360 entData)) "ADSK_XREC_PHOTOMETRICLIGHTINFO"))
                (progn
                  ; Get the filename/path stored for the Weblight
                  (setq fullName (cdr (assoc 300 xDict)))

                  ; Determine whether the filename is returned only or the full path
                  (if bIncludeFullPath
                    ; Get and attempt to resolve the relative path as needed
                    (setq fileName (ResolveRelativePath fullName (vl-string-trim "\\" (getenv "IESWEB"))))

                    ; Get the filename and extension only
                    (setq fileName (strcat (vl-filename-base fullName) (vl-filename-extension fullName)))
                  )

                  ; Check to see if the file entry already exists in the list
                  (if (not (member fileName fileList))
                    (setq fileList (cons fileName fileList))
                  )
                )
              )
            )
          )

          ; Get the next entity in the block
          (setq entName (entnext entName))

          ; If there is a next entity, get its DXF entity data
          (if (/= entName nil)
            (setq entData (entget entName))
          )
        )
      )
    )
   
    ; Return the next block in the Blocks symbol table, if *Model_SPACE
    ; is the current block name then get the first symbol in the Block table
    (if (= blkName "*MODEL_SPACE")
      (setq entBlkSym (tblnext "block" T))
      (setq entBlkSym (tblnext "block"))
    )

    ; Get the name of the next block
    (setq blkName (cdr (assoc 2 entBlkSym)))
  )
 
  ; Return a sorted list of filenames
  (vl-sort fileList '<) 
)

;; Returns a list of the image files referenced by the material definitions in the drawing
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (MaterialImagePathsList T)
;; Usage: (MaterialImagePathsList nil)
(defun MaterialImagePathsList (bIncludeFullPath / materialDict cnt val fileList)
  (if (setq materialDict (dictsearch (namedobjdict) "ACAD_MATERIAL"))
    ; Step through the definitions in the Materals dictionary
    (foreach val materialDict
      ; Check for the DXF group code 350, an xrecord
      (if (= (car val) 350)
        ; Check for the DXF group code values 3 (main material image) and 8 (releif pattern image)
        (foreach dxfCode '(3 8)
          (if (setq entData (assoc dxfCode (entget (cdr val))))
            ; Proceed if the image filename is not blank
            (if (/= (setq fullName (cdr entData)) "")
              (progn
                ; Determine whether the filename is returned only or the full path
                (if bIncludeFullPath
                  ; Get and attempt to resolve the relative path as needed
                  (setq fileName (ResolveRelativePath fullName (vl-string-trim "\\" (getvar "dwgprefix"))))

                  ; Get the filename and extension only
                  (setq fileName (strcat (vl-filename-base fullName) (vl-filename-extension fullName)))
                )

                ; Check to see if the file entry already exists in the list
                (if (not (member fileName fileList))
                  (setq fileList (cons fileName fileList))
                )
              )
            )
          )
        )
      )
    )
  )
 
  ; Return a sorted list of filenames
  (vl-sort fileList '<)
)

;; Returns a list of all plot settings files referenced by layouts and named page setups
;; sPlotSettingsType = "PC3", "CTB", or "STB" - CTB and STB values return the same values
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (PlotSettingsList "PC3" T)
;; Usage: (PlotSettingsList "CTB" nil)
(defun PlotSettingsList (sPlotSettingsType bIncludeFullPath / eDict val sName fileList)
  ; Define DXF Code to return
  (cond
    ((= (strcase sPlotSettingsType) "PC3")(setq dxfCode 2 paths (split (getenv "PrinterConfigDir") ";")))
    ((= (strcase sPlotSettingsType) "CTB")(setq dxfCode 7 paths (split (getenv "PrinterStyleSheetDir") ";")))
    ((= (strcase sPlotSettingsType) "STB")(setq dxfCode 7 paths (split (getenv "PrinterStyleSheetDir") ";")))
  )
 
  ; Get the layouts and plot settings dictionaries
  (foreach eDict (list (dictsearch (namedobjdict) "ACAD_LAYOUT")
                       (dictsearch (namedobjdict) "ACAD_PLOTSETTINGS"))
      ; Step through the dictionary
      ; Change to be foreach instead of while loop
      (foreach val eDict
        ; Check to see if the value is a dictionary entry
        (if (= (car val) 350)
          (progn
            (setq sName (cdr (assoc dxfCode (entget (cdr val)))))

            ; Model tab when set to "None" returns "none_device"
            (if (= sName "none_device")(setq sName "None"))

            ; Determine whether the filename is returned only or the full path
            (if bIncludeFullPath
              ; Look through the different printer configuration paths for the correct location of the file
              (foreach path paths
                (if (findfile (strcat path "\\" sName))
                  (setq sName (strcat path "\\" sName))
                )
              )
      
              ; Get the filename and extension only
              (setq sName (strcat (vl-filename-base sName) (vl-filename-extension sName)))
            )
    
            ; Check to see if the entry already exists in the list
            (if (not (member sName fileList))
              (setq fileList (cons sName fileList))
            )
          )
        )
      )
  )

  ; Return a sorted list of filenames
  (vl-sort fileList '<)
)

;; Returns a list of all Plot Configuration (PC3) files referenced by layouts and named page setups
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (PlotConfigurationPathsList T)
;; Usage: (PlotConfigurationPathsList nil)
(defun PlotConfigurationPathsList (bIncludeFullPath / )
  (PlotSettingsList "PC3" bIncludeFullPath)
)

;; Returns a list of all Plot Style (CTB/STB) files referenced by layouts and named page setups
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (PlotStylesPathsList T)
;; Usage: (PlotStylesPathsList nil)
(defun PlotStylesPathsList (bIncludeFullPath / )
  (if (= 1 (getvar "PSTYLEMODE"))
    (PlotSettingsList "CTB" bIncludeFullPath)
    (PlotSettingsList "STB" bIncludeFullPath)   
  )
)

;; Returns a list of the specified underlay files attached to the drawing
;; sUnderlayType = "DWF", "DGN", "PDF", "RCP", "NWC", or "NWD"
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (UnderlaysList "DWF" T)
;; Usage: (UnderlaysList "DGN" nil)
;; Usage: (UnderlaysList "PDF" T)
;; Usage: (UnderlaysList "RCP" nil)
;; Usage: (UnderlaysList "NWC" nil)
(defun UnderlaysList (sUnderlayType bIncludeFullPath / underlayDict val fullName fileName fileList)
  ; Get the underlay definition dictionary
  (cond
    ((= (strcase sUnderlayType) "DWF")(setq underlayDict (dictsearch (namedobjdict) "ACAD_DWFDEFINITIONS")))
    ((= (strcase sUnderlayType) "DGN")(setq underlayDict (dictsearch (namedobjdict) "ACAD_DGNDEFINITIONS")))
    ((= (strcase sUnderlayType) "PDF")(setq underlayDict (dictsearch (namedobjdict) "ACAD_PDFDEFINITIONS")))
    ((= (strcase sUnderlayType) "RCP")(setq underlayDict (dictsearch (namedobjdict) "ACAD_POINTCLOUD_EX_DICT")))
    ((or (= (strcase sUnderlayType) "NWC")
         (= (strcase sUnderlayType) "NWD"))(setq underlayDict (dictsearch (namedobjdict) "ACAD_BIM_DEFINITIONS")))
  )

  ; Step through the DWF underlay definition dictionary
  ; Change to be foreach instead of while loop
  (foreach val underlayDict
    ; Check to see if the value is a dictionary entry
    (if (= (car val) 350)
      (progn
        (setq fullName (cdr (assoc 1 (entget (cdr val)))))

        ; Determine whether the filename is returned only or the full path
        (if bIncludeFullPath
          ; Get and attempt to resolve the relative path as needed
          (setq fileName (ResolveRelativePath fullName (vl-string-trim "\\" (getvar "dwgprefix"))))

          ; Get the filename and extension only
          (setq fileName (strcat (vl-filename-base fullName) (vl-filename-extension fullName)))
        )

        ; Check to see if the entry already exists in the file list since duplicates could exist
        (if (not (member fileName fileList))
          (setq fileList (cons fileName fileList))
        )
      )
    )
  )

  ; Return a sorted list of filenames
  (vl-sort fileList '<)
)

;; Returns a list of all DWF files attached to the drawing
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (DWFUnderlaysPathsList T)
;; Usage: (DWFUnderlaysPathsList nil)
(defun DWFUnderlaysPathsList (bIncludeFullPath / )
  (UnderlaysList "DWF" bIncludeFullPath)
)

;; Returns a list of all DGN files attached to the drawing
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (DGNUnderlaysPathsList T)
;; Usage: (DGNUnderlaysPathsList nil)
(defun DGNUnderlaysPathsList (bIncludeFullPath / )
  (UnderlaysList "DGN" bIncludeFullPath)
)

;; Returns a list of all PDF files attached to the drawing
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (PDFUnderlaysPathsList T)
;; Usage: (PDFUnderlaysPathsList nil)
(defun PDFUnderlaysPathsList (bIncludeFullPath / )
  (UnderlaysList "PDF" bIncludeFullPath)
)

;; Returns a list of all the point cloud files attached to the drawing
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (PointCloudsPathsList T)
;; Usage: (PointCloudsPathsList nil)
(defun PointCloudsPathsList (bIncludeFullPath / )
  (UnderlaysList "RCP" bIncludeFullPath)
)

;; Returns a list of all the Navisworks files attached to the drawing
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (CoordinationModelPathsList T)
;; Usage: (CoordinationModelPathsList nil)
(defun CoordinationModelPathsList (bIncludeFullPath / )
  (UnderlaysList "NWD" bIncludeFullPath)
)

;; Returns a list containing the sheet set file name associated with the drawing
;; bIncludeFullPath = T - Full file path is returned
;; bIncludeFullPath = nil - Filename and extension only are returned
;; Usage: (AssociatedDSTPathList T)
;; Usage: (AssociatedDSTPathList nil)
(defun AssociatedDSTPathList (bIncludeFullPath / shSetDict bFlag val fullName fileName fileList)
  ; Get the Sheet Set data dictionary
  (setq shSetDict (dictsearch (namedobjdict) "AcSheetSetData")
        bFlag nil
  )

  ; Step through the records in the dictionary until ShSetFileName is found
  (foreach val shSetDict
    (if (= fileList nil)
      ; Check for the DXF group code 3
      (if (= (car val) 3)
        ; If DXF group code 3 was found, check to see if the Sheet Set FileName record was found
        (if (= (cdr val) "ShSetFileName")
          (setq bFlag T)
        )

        ; If the Sheet Set FileName record was found, get the Sheet Set filename
        (if (and (= (car val) 350) (= bFlag T))
          (progn
            ; Get the DST filename from the record
            (setq fullName (cdr (assoc 1 (entget (cdr val)))))

            ; Determine whether the filename is returned only or the full path
            (if bIncludeFullPath
              ; Get the full filename
              (setq fileName fullName)

              ; Get the filename and extension only
              (setq fileName (strcat (vl-filename-base fullName) (vl-filename-extension fullName)))
            )

            ; Append the filename to the list
            (setq fileList (cons fileName fileList))
          )
        ) 
      )
    )
  )

  ; Return the file list, which should only contain one value
  fileList
)

I hope that the code samples in this article help you:

  • migrate any existing programs that rely on the IAcadFileDependencies and IAcadFileDependency classes so they can be used in AutoCAD 2018-based products
  • think differently on how to get information about the files your drawing requires to plot correctly

If you have any comments or thoughts on this samples in this article, let me know as it would be great to get some input.

Sincerely,
  Lee

Posted at 07:57 AM in AutoCAD, AutoCAD 2018, AutoCAD based products, AutoLISP/Visual LISP, Programming | | Comments (0)

| | | Pin It! | | |

What's New In the AutoCAD 2018 APIs and Developer Documentation

AutoCAD 2018 marks for me the 11th product release that I worked on, it is hard to believe that I started working with the AutoCAD team about 12 years ago now (2 years as a consultant and going on 10 years as an employee). Prior to joining Autodesk, I was a developer for a fairly large company and an ADN member that lived and died by the AutoCAD developer documentation.  For me, this release marks a special milestone that I have been pushing towards for several years now and that is the merging of the AutoCAD platform developer documentation.

The AutoCAD application programming interfaces (APIs) this release has seen some changes, based on your usage of certain areas the changes might feel minor while to others they might be major. In this article, I simply highlight the changes that were introduced and don't go into any great depth; you can find out specifics about the API changes in the developer documentation itself.  I do plan on covering some specific changes in future articles though.

The AutoCAD developer documentation can be found at:
http://help.autodesk.com/view/OARX/2018/ENU/

Some of the developer documentation (AutoLISP and ActiveX), can also be found while searching in the AutoCAD product documentation:
http://help.autodesk.com/view/ACD/2018/ENU/

The following outlines the changes that were made to the AutoCAD APIs:

General Updates

  • Developer Documentation Home Page has been expanded and slightly reorganized:
    • AutoLISP and DCL related links are now broken out into their own subsections
    • Documentation for the non-standard AutoCAD ActiveX libraries has been broken out into their own subsection
    • Managed .NET Reference guide is now merged into the online documentation
    • ObjectARX documentation has now been merged into the online documentation
  • Updated the HEADER Section of the DXF documentation to include the AC1032 value for the AutoCAD 2018 drawing format of the $ACADVER variable
  • Documentation was centralized and a table of contents (TOC) was reintroduced for all publications

AutoLISP

DCL

  • No new or changed functions/tiles this release.

ActiveX/COM

  • No new classes were added, but the ProgIds for the following have changed which might impact your existing programs:
    • AcadAcCmColor
    • AcadApplication
    • AcadLayerStateManager
    • AcadSecurityParams
  • The IAcadFileDependencies and IAcadFileDependency classes are now obsolete as a result of the File Dependency feature being removed
  • The AcSaveAsType enum was updated to include constants for the new drawing file format
  • Documentation continues to be available online through the AutoCAD product help and now the AutoCAD developer documentation site, and offline as CHM files in the %ProgramFiles%\Common Files\Autodesk Shared\en-US\ directory; the two CHM files are named acad_aag.chm and acadauto.chm
  • Historical list of changes from AutoCAD 2000 through AutoCAD 2018 can be used to identify potential problems in existing programs(http://help.autodesk.com/view/OARX/2018/ENU/?guid=GUID-F3522375-9407-48B7-BE25-E24BC07C5F23)

Managed .NET

ObjectARX

JavaScript

Hope you found this overview of the changes to the AutoCAD APIs and developer documentation helpful.

Sincerely,
  Lee

Posted at 04:11 PM in AutoCAD 2018, AutoLISP/Visual LISP, C++, ObjectARX, ObjectARX 2018 SDK, Programming, VB.NET | | Comments (2)

| | | Pin It! | | |

Debugging AutoLISP Programs - Part 2: Basic Debugging

The AutoLISP programming language supports some basic debugging techniques that can be utilized to help troubleshoot problems within a custom program. Displaying messages or values during the execution of a custom program can be beneficial in identifying the statement that is failing during execution. By looking at the last message or value returned, it will give you a basic or exact idea on where to start looking for the problem within the custom program based on the number of messages placed throughout your custom program.

These AutoLISP functions can be helpful in providing basic information in the AutoCAD user interface which can be used to determine where a program might have failed:

  • alert – Displays a message box containing a text message.
    Syntax: (alert message)
  • princ – Displays a value assigned to a variable or returned by an expression, or a text message at the Command prompt. This function can also be used to write a value to an external file when the optional file descriptor is provided.
    Syntax: (princ [expression [file_descriptor]])
  • prompt – Displays a text message or string value at the Command prompt.
    Syntax: (prompt message)

You might use the previously mentioned functions to display basic or more specific messages to help identify which code statements were recently executed. Examples of basic messages might be:

  • "Here1", "Here2", "HereX"
  • "Debug1", "Debug2", "Debug3"
  • "A", "B", "C"

More specific messages that you might use are:

  • "Starting While loop to modify selected objects"
  • "Updating DXF data for an object"
  • "Removing dictionary entries"

The previously mentioned functions are useful for displaying information in the AutoCAD user interface; it can also be beneficial to write messages and values out to an external log file.  In addition to the PRINC function, the following AutoLISP functions can also be used to output information to the Command prompt or an external log file:

  • prin1 – Displays a value assigned to a variable or returned by an expression, or a text message at the Command prompt or writes it out to an external file if a file descriptor is provided. Strings containing control characters are expanded.
    Syntax: (prin1 [expression [file_descriptor]])
  • print – Displays a value assigned to a variable or returned by an expression, or a text message at the Command prompt or writes it out to an external file if a file descriptor is provided.
    Syntax: (print [expression [file_descriptor]])

The following code example creates a blue circle using the ActiveX/COM library and demonstrates how some of the previously mentioned functions can be used to help debug a program:

; Load COM environment
(vl-load-com)

; Create a blue circle using Visual LISP
(defun c:CreateCircle-VL ( / acadObj docObj spaceObj cenPoint circObj)
  ; Create a reference to AutoCAD
  (setq acadObj (vlax-get-acad-object))

  (princ acadObj)
  (terpri)
 
  ; Create a reference to the current drawing
  (setq docObj (vla-get-activedocument acadObj))

  (princ acadObj)
  (terpri) 
  (prompt "Determine current space")
  (terpri)
 
  ; Get a reference to the current space
  (if (= (vla-get-activespace docObj) acModelSpace)
    (setq spaceObj (vla-get-modelspace docObj))
    (setq spaceObj (vla-get-paperspace docObj))
  )

  (princ spaceObj)
  (terpri) 
  (prompt "Start object definition")
  (terpri)
 
  ; Create the center point for the circle
  (setq cenPoint (vlax-make-safearray vlax-vbdouble '(0 . 2)))
  (vlax-safearray-fill cenPoint '(5.0 5.0 0.0))

  (princ cenPoint)
  (terpri)
 
  ; Create a circle at 5,5 in a radius of 1.75
  (setq circObj (vla-addcircle spaceObj cenPoint 1.75))

  (princ circObj)
  (terpri)
 
  ; Change the color of the circle to blue
  (vla-put-color circObj 5)

  (prompt "End object definition") 
  (terpri)
 (princ)
)

When executed, the previous example displays the values of several variables using the PRINC function and messages with the PROMPT function at the Command prompt. The following is a sample of the output displayed:

Command: CREATECIRCLE-VL
#<VLA-OBJECT IAcadApplication 00000001400d6188>
#<VLA-OBJECT IAcadApplication 00000001400d6188>
Determine current space
#<VLA-OBJECT IAcadModelSpace 000000003285d808>
Start object definition
#<safearray...>
#<VLA-OBJECT IAcadCircle 0000000039fe7f88>
End object definition

Once you are done debugging, you would normally comment out or remove each statement that simply outputs the values and messages that the user wouldn't normally need to see.  The downside to this though is that there could be hundreds of statements that you might need to comment out or remove each time you debug your program, what if there was a better approach to using messages to perform basic debugging.  Over the years, I created a utility library specific for handling debug messages. This library allows you to display messages at the Command prompt or to a log file, and even disable the feature all at once without needing to comment or remove the debugging statements.

The debug utility library that I wrote consists of three global variables and five functions:

  • *GLOBAL-DEBUG-LOGFILE* - Global variable that contains the log file name and location
  • *GLOBAL-DEBUG-LOGGING* - Global variable that can be used to determine if logging is enabled (T or nil)
  • *GLOBAL-DEBUG-ENABLED* - Global variable used to determine if debugging is enabled (T or nil)
  • debug-mode - Enables/disables the debug utility
  • debug-get-enabled - Gets the current status of the debug utility; enabled or disabled
  • debug-get-logmode - Gets the current status of log mode; enabled or disabled
  • debug-get-logfile - Gets the name and location of the log file
  • debug - Accepts the value that should be displayed at the Command prompt or output to the log file

The following is what the actual function definitions look like from my debug utility library:

; Global debugging variables
; *GLOBAL-DEBUG-LOGFILE* - Log file name and location
; *GLOBAL-DEBUG-LOGGING* - Log enabled
; *GLOBAL-DEBUG-ENABLED* - Enable debugging (T or nil)

; Enable debugging - Example usage (debug-mode 2)
; 0 or nil - Disables debugging
; 1 or T   - Enables debugging at the Command prompt
; 2        - Enables debugging and outputs to a log file

(defun debug-mode (enable / )
  (cond
    ((or (= enable 0)(= enable nil))
      (if (= (type *GLOBAL-DEBUG-LOGFILE*) 'FILE)
        (progn
          (close *GLOBAL-DEBUG-LOGFILE*)
          (setq *GLOBAL-DEBUG-LOGFILE* nil)
        )
      )

      (setq *GLOBAL-DEBUG-ENABLED* nil
            *GLOBAL-DEBUG-LOGGING* nil
            *GLOBAL-DEBUG-LOGFILE* nil)
    )
    ((or (= enable 1)(= enable T))
      (setq *GLOBAL-DEBUG-ENABLED* 1 *GLOBAL-DEBUG-LOGGING* 0)
      (if (= (type *GLOBAL-DEBUG-LOGFILE*) 'FILE)
        (progn
          (close *GLOBAL-DEBUG-LOGFILE*)
          (setq *GLOBAL-DEBUG-LOGFILE* nil)
        )
      )
    )
    ((= enable 2)
      (setq *GLOBAL-DEBUG-ENABLED* 1 *GLOBAL-DEBUG-LOGGING* 1)
      (if (/= (type *GLOBAL-DEBUG-LOGFILE*) 'FILE)
        (setq *GLOBAL-DEBUG-LOGFILE* (open (strcat (getvar "tempprefix") "global-debug.log") "a"))
      ) 
    )
  )
 (princ)
)

; Get the current state of debugging
(defun debug-get-enabled ( / )
  *GLOBAL-DEBUG-ENABLED*
)

; Get the current logging state
(defun debug-get-logmode ( / )
  *GLOBAL-DEBUG-LOGGING*
)

; Get the name of the current log file
(defun debug-get-logfile ( / )
  *GLOBAL-DEBUG-LOGFILE*
)

; Debug function is a wrapper for the functionality
; of the princ and print functions. Feature is turned on or
; off with the debug-mode function.
(defun debug (value / )
  (if (debug-get-enabled)
    (if (/= (debug-get-logmode) 1)
      (progn (princ value)(terpri))
      (print value (debug-get-logfile))
    )
  )
 (princ)
)

The following is a revision of the CreateCircle-VL, shown earlier in this posting, which demonstrates the usage of the debug utility library compared to separate PRINC and PROMPT functions:

; Load COM environment
(vl-load-com)

; Enable debug mode
(debug-mode 1)

; Create a blue circle using Visual LISP
(defun c:CreateCircle-VL ( / acadObj docObj spaceObj cenPoint circObj)
  ; Create a reference to AutoCAD
  (setq acadObj (vlax-get-acad-object))

  (debug acadObj)
 
  ; Create a reference to the current drawing
  (setq docObj (vla-get-activedocument acadObj))

  (debug acadObj)
  (debug "Determine current space")
 
  ; Get a reference to the current space
  (if (= (vla-get-activespace docObj) acModelSpace)
    (setq spaceObj (vla-get-modelspace docObj))
    (setq spaceObj (vla-get-paperspace docObj))
  )

  (debug spaceObj) 
  (debug "Start object definition")
 
  ; Create the center point for the circle
  (setq cenPoint (vlax-make-safearray vlax-vbdouble '(0 . 2)))
  (vlax-safearray-fill cenPoint '(5.0 5.0 0.0))

  (debug cenPoint)
 
  ; Create a circle at 5,5 in a radius of 1.75
  (setq circObj (vla-addcircle spaceObj cenPoint 1.75))

  (debug circObj)
 
  ; Change the color of the circle to blue
  (vla-put-color circObj 5)

  (debug "End object definition")
 (princ)
)

When the revised code is loaded and executed, variable values and messages are displayed at the Command prompt.  If you execute the statement (debug-mode 0) at the Command prompt or change the (debug-mode 1) statement to (debug-mode 0) and reload the sample code, debugging is disabled and the variables and messages are no longer displayed at the Command prompt.

Hope this article makes you think differently about utilizing basic messages when debugging your custom programs.

Sincerely,
  Lee 

Posted at 08:04 AM in AutoCAD, AutoCAD based products, AutoLISP/Visual LISP, Programming | | Comments (0)

| | | Pin It! | | |

Debugging AutoLISP Programs - Part 1

Debugging AutoLISP programs is "A Zen like Experience," said no one ever... Although, I have tried to convince a number of people that it is very a calming and soothing activity over the years.  There are a number of different debugging techniques and tools that can be used to find and handle errors much easier, whether you are developing in AutoCAD on Windows or Mac OS.

Note: There are more debugging tools available on Windows than Mac OS at this time, which could change in the future.  If you do plan on developing a number of AutoLISP programs, you might want to consider getting access to the Windows version of AutoCAD if you are a user of Mac OS.  Just a simple suggestion, not something you must do.

The thought of debugging and error handling doesn't come naturally to new and even seasoned developers, as most are simply focused on solving the problem at hand and not all the extra baggage that often goes with well written code.  Of course, well written code is in the eye of the developer that is look at it in the current moment.  Also if it isn't broken, then why change or fix a process\approach to a solution?  After many years of writing custom programs, I have learned that debugging and error handling need to be some of the very first things to consider when writing any custom program.

While I am just as guilty for jumping in (feet, hands, and compiler first) and writing code, this approach can get you to the solution faster but can lead to some bad habits and headaches down the road.  One of the things that I have found useful in getting me to slowdown and think things through more clearly is the creation of a flowchart.  If you are not already creating one today, I recommend creating a flowchart to help you visualize all the logical paths through your programs.  Flowcharts make it easier to identify choices as well as potential failure points that need to be handled.  A flowchart can also be a great way to communicate the design of a program with other that are less technical.  Products like Microsoft Visio or Lucidchart are designed to create flowcharts, but the same can be accomplished with Microsoft Word, PowerPoint, and other word processor and presentation products.

Potential failure points can be introduced when a:

  • User has an opportunity to provide input
  • Global variable is used
  • Program relies on a specific folder structure or an external data/support file, such as a drawing or text file or Windows registry entries
  • Program utilizes an ActiveX/COM or external library

AutoLISP/Visual LISP offers a variety of built-in functions and features to help you track down problems and handle errors. You can utilize the following debugging and error handling functions and features when developing your custom programs:

  • Basic debug messaging - AutoLISP functions alert, prompt, print1, prin1, and princ
  • Basic function tracing facilities - AutoLISP functions trace and untrace
  • Visual LISP IDE (Windows only) - Breakpoints, watch window, inspect window, and trace stack
  • Data validating functions - AutoLISP functions numberp, zerop, boundp, minusp, listp, vl-consp, type, vl-symbolp, and vl-file-directory-p
  • Error catching - AutoLISP functions vl-catch-all-apply, vl-catch-all-error-message, and vl-catch-all-error-p
  • Custom error handling - AutoLISP functions *error*, vl-exit-with-error, vl-exit-with-value, *pop-error-mode*, *push-error-using-command*, and *push-error-using-stack*
  • Undo grouping - AutoCAD UNDO command allows you to begin and end an undo group so that all changes made by your program can be reverted using the AutoCAD U command

Hope you find this overview topic helpful, I plan on following up with future articles that dive more into specifics about each debugging technique and tool that I mentioned.

Sincerely,
  Lee

Posted at 02:37 PM in AutoCAD, AutoCAD based products, AutoCAD for Mac, AutoLISP/Visual LISP, Programming | | Comments (0)

| | | Pin It! | | |

Calculating Elapsed Time with AutoLISP

Why calculate elapsed time or differences in time you might be wonder?  There are primarily two reasons to do this:

  • Determine the time it took to complete a task; for calculating cost savings or Return on Investment (ROI)
  • Generate a unique name

The need to the calculate cost to make something or complete a task/project is nothing new and happens everyday across every company.  When calculating cost savings, you need to consider the following pieces of information:

  • Does an action/activity have to be performed?
  • How often is the action/activity performed?
  • How much does the action/activity cost when performed?
  • How long does it currently and/or previously take to complete the action/activity?

Even though calculating cost savings is an important conversation, that is best left for a future article.

Until AutoCAD 2017, the date and time stored in the CDATE and DATE system variables were the best for calculating time differences in an AutoCAD-based product as they included milliseconds.  Starting with AutoCAD 2017-based products, the CDATE and DATE system variables no longer include milliseconds.  Other date related system variables, such TDCREATE were also affected by this change.  I discussed this change across several articles recently, which can be found here:

Computers can easily handle hundreds of thousands of instructions per second based on their architecture, so milliseconds is a much better measurement in time to measure compared to a full second.  Since the CDATE and DATE system variables no longer include milliseconds, the MILLISECS system variable can be used to calculate time differences in milliseconds.  As part of a custom AutoLISP program, you might store the current time of MILLISECS as the start time and then as part of the final tasks to be performed you might get the end value and subtract the differences of the two time values to get the time that has elapsed. 

Command: (setq start (getvar "MILLISECS"))
25494432

Command: (setq end (getvar "MILLISECS"))
25499471

Command: (- end start)
5039

Of course, it is always best to wrap any functionality that you might want to use across multiple programs in a utility function; making it easier to manage and maintain.  The following is an example of such a function, the Timer function wraps the functionality that stores the start time and returns the time difference in a single function.

; Global variable for the timer
(setq *g-timer-start-time* nil)

; Stores the current time when called, and then returns
; the time difference when called the next time. Time
; difference is returned in milliseconds.
; Usage: (timer)
(defun timer ( / rTimeDiff)
  ; Check to see if the function was previously called
  (if (= *g-timer-start-time* nil)
    (progn
      ; Stores the current milliseconds
      (setq *g-timer-start-time* (getvar "MILLISECS"))
      (princ)
    )
    (progn
      ; Calculates and returns the time difference
      (setq rTimeDiff (- (getvar "MILLISECS") *g-timer-start-time*)
            *g-timer-start-time* nil)
      rTimeDiff
    )
  )
)

The following shows a example of how you might use the Timer function with your custom programs and the output that is returned:

(defun c:CounterLoop ( / loop cnt cur)
  ; Store the current time
  (timer)

  ; Loop 10000 times and output a message every 100 loops
  (setq loop 0 cnt 0)
  (repeat 10000
    (setq cur (fix (/ loop 100.0)))
    (if (= cnt cur)
      (progn
        (prompt (strcat "\nLoop: " (itoa loop)))
        (setq cnt (1+ cnt)) 
      )
    )
    (setq loop (1+ loop))
  )

  (prompt (strcat "\nLoop: " (itoa loop)))

  ; Output the number of elapsed milliseconds
  (prompt (strcat "\nElapsed time (ms): " (itoa (timer))))
 (princ)
)

Partial output from the previous example:

...
Loop: 9700
Loop: 9800
Loop: 9900
Loop: 10000
Elapsed time (ms): 63

While most programs execute very quickly, some might take much longer based on the tasks they perform.  Programs that take longer to execute might complete in tens of thousands of milliseconds, which can be hard to determine just how many seconds or minutes might have elapsed.  The following functions can be used to calculate the differences in time and format milliseconds or seconds as hours, minutes, seconds, and milliseconds:

;| Takes two values in milliseconds and returns the
   difference as an integer/long or double/float

   bMilliseconds = T   - Return value in milliseconds
   bMilliseconds = nil - Return value in seconds

   Usage: (TimeDiff T1 T2 T) - Milliseconds example
   Usage: (TimeDiff T1 T2 nil) - Seconds example

   Example(s)
   (setq T1 24092498)
   (setq T2 24188267)
   (TimeDiff T1 T2 T)
   95769

   (TimeDiff T1 T2 nil)
   95.769
|;
(defun TimeDiff (nStart nEnd bReturnMilliseconds / nDiff)
 
  ;; Get the time difference
  (if (> nStart nEnd)
    (setq nDiff (- nStart nEnd))
    (setq nDiff (- nEnd nStart))
  )

  ;; Return the time difference in milliseconds or seconds
  (if (= bReturnMilliseconds nil)
    (/ nDiff 1000.0)
    nDiff
  )
)

;| Formats milliseconds or seconds into the
   HH:MM:SS:mmm (00:00:00:000) format

   bMilliseconds = T   - Time is expressed in milliseconds
   bMilliseconds = nil - Time is expressed in seconds

   Usage: (FormatTime 122.021 nil) - Seconds example
   Usage: (FormatTime 95769 T)     - Milliseconds example

   Example(s)
   (setq T1 24092498)
   (setq T2 24188267)
   (FormatTime (TimeDiff T1 T2 T) T)
   "00:01:35:769"

   (FormatTime 122.021 nil)
   "00:02:02:021"
|;
(defun FormatTime (dTime bMilliseconds / dDiff sHrs nHrs sMins
                                         nMins sSecs sMSecs nSecs)
  (if bMilliseconds
    (setq dDiff (/ dTime 1000.0))
    (setq dDiff dTime)
  )

  ; Set the default values
  (setq sHrs   "00"
        sMins  "00"
        sSecs  "00"
        sMSecs "000")
   
  ; Get the number of seconds
  (setq nSecs (fix dDiff))

  ; Get the number of milliseconds left
  (setq sMSecs (rtos (* (- dDiff nSecs) 1000.0) 2 0))

  ; Get the number of minutes
  (setq nMins (/ nSecs 60)
        sMins (itoa nMins))

  ; Get the number of hours and minutes, if minutes are greater than 60
  (if (> nMins 60)
    (setq nHrs (fix (/ nMins 60))
          sHrs (itoa nHrs)
          nMins (- nMins (* nHrs 60))
          sMins (itoa nMins))
  )

  ; Get the number of seconds
  (setq sSecs (itoa (- nSecs (* (/ nSecs 60) 60))))

  ; Format Hours to "00"
  (if (= (strlen sHrs) 1)
    (setq sHrs (strcat "0" sHrs))
  )

  ; Format Minutes to "00"
  (if (= (strlen sMins) 1)
    (setq sMins (strcat "0" sMins))
  )

  ; Format Seconds to "00"
  (if (= (strlen sSecs) 1)
    (setq sSecs (strcat "0" sSecs))
  )

  ; Format Milliseconds to "000"
  (while (< (strlen sMSecs) 3)
    (setq sMSecs (strcat "0" sMSecs))
  )

  ; Return the output in the 00:00:00:000 format
  (strcat sHrs ":" sMins ":" sSecs ":" sMSecs) 
)

Hope you found the information in this topic helpful.

Sincerely,
  Lee

 

Posted at 08:00 AM in AutoCAD, AutoCAD based products, AutoLISP/Visual LISP, Programming | | Comments (0)

| | | Pin It! | | |

Getting the Current Date/Time with AutoLISP - Part 2

Needing to populate a title block or stamp a drawing with the current date/time is a very common task in the AutoCAD product along with determining the time it might have taken to execute a custom program for return of investment (ROI) analysis.  AutoCAD-based products support several system variables that can be used to determine the current date/time, these system variables are:

  • CDATE - Stores the current date and time as a decimal value.
  • DATE - Stores the current date and time in Modified Julian Date format.
  • MILLISECS - Stores the current number of milliseconds since the computer was booted.

NOTE: Starting with AutoCAD 2017, the CDATE and DATE system variables no longer store the current time down to milliseconds.

DATE System Variable

The DATE system variable can be used to get the current date and time within the AutoCAD environment while using AutoLISP, but unlick the CDATE system variable will require some work to transform the Modified Julian Date format into something recognizable.  When queried, the DATE system variable returns a value as a real number.  The GETVAR function is used to return the value of a system variable for use with the AutoLISP programming language.

Here is an example of getting the value stored in the DATE system variable:

Command: (getvar "DATE")
2.45781e+06

As previously mentioned, the value of the DATE system variable is a real number.  By default, it isn't possible to see the full value of the DATE system variable without a bit of extra help.  It is best to convert the real number to a string, so you can see and work with the full value which can be accomplished using the RTOS function.  The RTOS function accepts 3 arguments, the real number to convert to a string and two optional arguments which represent the linear unit mode and precision in which the value should be formatted.

Here is an example of converting the value stored in the DATE system variable to a string that represents the real value as a decimal with a precision of 9:

Command: (rtos (getvar "DATE") 2 9)
"2457806.411851852"

The date part of the Modified Julian Date format is the integer part of the number (what is to the left of the decimal), while time is represented by the fraction part of the number (what is to the right of the decimal).  The date is the number of days since Noon on January 1, 4713 BC... Why not, Noon makes sense and time is expressed as a fraction of the since Midnight which can be calculated by multiplying the fraction by 86,400.  If your head is spinning, you are not the only one.  Feel free to take up some light reading on the subject about the Julian Day.  I am sure you are thinking about just sticking with the Gregorian Calendar whenever possible since it is familiar to most people on the planet, which is easier said than done when working with dates in AutoCAD as drawing creation, last updated, and several other dates are all stored as Modified Julian Dates.

These system variables also store dates and/or time values expressed as a Modified Julian Date:

As you can imagine based on the description, there is a bit of math that is involved to calculate both the date and time using the value returned by the DATE system variable.  While there are no standard AutoLISP functions available for converting a Julian Date to equivalent Gregorian Calendar Date, there are 5 AutoLISP functions in the Express Tools that can be used to make the task easier.  These functions are made available after the Julian.lsp file is loaded into the AutoCAD environment, which can be done using the DATE command or the AutoLISP load function.

The date related AutoLISP functions that are accessible after the Julian.lsp file is loaded are:

  • CTOJ - Converts a Gregorian Calendar date and time into the Julian date
  • DTOJ - Converts an AutoCAD formatted calendar date and time into the Julian date
  • JTOC - Converts a Julian date to a list that contains a Gregorian Calendar date and time
  • JTOD - Converts a Julian date to an AutoCAD formatted calendar date and time
  • JTOW - Returns the day of the week based on the specified Julian day

Command: (jtoc (getvar "date"))
(2017 2 22 9 21 27.0)

Command: (rtos (jtod (getvar "date")) 2 6)
"20170222.092127"

Since the AutoLISP functions are defined in a LSP file and that LSP file is not compiled, it is possible to open the Julian.lsp file and see how the functions were written.

Converting a Julian Date to  A Gregorian Calendar Date with AutoLISP

While the functions defined in the Express Tools are great, there is one downside to them and that is they are only available when the Express Tools are installed.  This code sample demonstrates how to take the Julian Date from the DATE system variable and convert that value into the equivalent value returned by the CDATE system variable:

; Converts a Modified Julian Date to the same output as CDATE
; Usage: (Julian2DateTime (getvar "DATE"))
(defun Julian2DateTime (julianTime / jDate jTime AA BB CC DD
                                     EE FF GG Y N D HH MM SS)
  ; Break the real number into its integer and fractional parts
  ; Time is based on a fraction of a day, so multiplying that fraction
  ; by 86,400 gives you the number of seconds that have passed
  (setq jDate (fix julianTime)
        jTime (* 86400.0 (- julianTime jDate)))

  ; Calculate the Gregorian date from the Modified Julian Date
  ; based on the whole number
  (setq AA (+ jDate 68569))
  (setq BB (/ (* 4 AA) 146097))
  (setq CC (- AA (/ (+ (* 146097 BB) 3) 4)))
  (setq DD (/ (* 4000 (+ CC 1)) 1461001))
  (setq EE (+ (- CC (/ (* 1461 DD) 4)) 31))
  (setq FF (/ (* 80 EE) 2447))
  (setq GG (/ FF 11))

  ; Year
  (setq Y (+ (* 100 (- BB 49)) DD GG))
  ; Month
  (setq M (* (- (+ FF 2) 12) GG))
  ; Date
  (setq D (- EE (/ (* 2447 FF) 80)))

  ; Calculate the time from the decimal value of the Modified Julian Date
  ; Hours
  (setq HH (fix (/ jTime 3600.0)))
  (setq jTime (- jTime (* HH 3600.0)))
  ; Minutes
  (setq MM (fix (/ jTime 60.0)))
  ; Seconds
  (setq SS (fix (- jTime (* MM 60))))

  ; Output the date as a string in the YYYYMMDD.HHMMSS format to match CDATE
  (strcat (itoa Y)
   (if (> M 10)(itoa M)(strcat "0" (itoa M)))
   (if (> D 10)(itoa D)(strcat "0" (itoa D)))
          "."
   (if (> HH 10)(itoa HH)(strcat "0" (itoa HH)))
   (if (> MM 10)(itoa MM)(strcat "0" (itoa MM)))
   (if (> SS 10)(itoa SS)(strcat "0" (itoa SS)))
  )
)

The output that is generated from the Julian2DateTime function will look similar to the following:

(Julian2DateTime (getvar "DATE"))
"20170222.093707"

(Julian2DateTime (getvar "TDCREATE"))
"20170222.090846"

Hope this article gives you a better understanding of how the value of the DATE system variable can be used to get and format the current date with AutoLISP.

Other related articles:

Sincerely,
  Lee

Posted at 09:43 AM in AutoCAD, AutoCAD based products, AutoLISP/Visual LISP, Programming | | Comments (0)

| | | Pin It! | | |

PSA: Additional Date Related System Variables to Be Aware Of in Custom AutoLISP Programs

Recently, I mentioned that the CDATE and DATE system variables no longer store time down to milliseconds. In addition to those system variables, the following system variables are now accurate to the nearest second starting with AutoCAD 2017, whereas earlier releases they included milliseconds :

Any scripts or custom programs that use these system variables should be verified that they work properly with AutoCAD 2017.  In most cases, the scripts and custom programs should work as expected with the exception of the milliseconds part of the time value being returned.  In most cases, milliseconds is now returned as "000" or a similar value that is not as accurate as AutoCAD 2016 and earlier.

The following article is also related to the CDATE and DATE system variables:

Sincerely,
  Lee

Posted at 09:02 AM in AutoCAD 2017, AutoCAD based products, AutoLISP/Visual LISP, Programming, Scripts | | Comments (0)

| | | Pin It! | | |

PSA: Be On the Look Out for Usage of the Quick and QUI Object Snap Modes in Scripts and Custom Programs

Upgrading from AutoCAD 2015 or earlier to AutoCAD 2016 or AutoCAD 2017?

If you are in the process of upgrading to a recent release of an AutoCAD-based product, you will want to check the scripts, action macros, and custom programs that you use for any usage of the -OSNAP command, OSMODE system variable, or AutoLISP OSNAP function.  Starting with AutoCAD 2016, the Quick object snap or 'qui' mode is no longer supported and result in unexpected behavior if used.

-OSNAP Command

When the Quick object snap is used with the -OSNAP command in AutoCAD 2016 and later, the Invalid object snap modes. error message is displayed along with the command re-prompting for a valid list of object snaps again.  The prompt being displayed again could cause potential problems with future commands, keywords, and values in the script or custom program.

Command: -OSNAP
Current osnap modes: End,Cen,Int,Ext
Enter list of object snap modes: QUI,END
Invalid object snap modes.
Enter list of object snap modes:

Solution: Remove QUI from the list of object snaps passed to the -OSNAP command, and then retest the affected scripts and custom programs.

OSMODE System Variable

Starting with AutoCAD 2016, the bitcode value of 1024 no longer represents the Quick object snap but rather the Geometric Center object snap.  Since the 1024 bitcode value was repurposed, any script or custom program that expects the Quick object snap might produce unexpected results.

Solution: If your program doesn't require the Geometric Center object snap, you might want to remove the 1024 bitcode value from the sum that is being assigned to the OSMODE system variable as part of the script or custom program.  Once the value has been changed or a decision is to leave it unchanged is made, be sure to test the script or custom program to ensure it is working as expected.

AutoLISP OSNAP Function

The AutoLISP OSNAP function returns a list representing a 3D point or a nil value based on the provided point and comma-delimited string that represents the object snap modes to use.  The 3D point returned is calculated based on the objects near the point provided and within the area of the aperture box along with the object snap modes listed, nil is returned if no point could be calculated based on the lack of objects within the aperture box or none of the object snap modes listed being valid for the objects in the aperture box. If the '_qui' object snap mode is specified in a program that is executed by AutoCAD 2016 or later, the point returned will always be nil since the object snap no longer exists.

Solution: Remove qui or _qui from the comma-delimited string that represents the list of object snap modes to be passed to the OSNAP function.  After the object snap mode has been removed, retest the affected custom program.

Hope you found the information in this article useful.

Sincerely,
  Lee

Posted at 12:57 PM in AutoCAD, AutoCAD based products, AutoLISP/Visual LISP, Programming, Scripts | | Comments (0)

| | | Pin It! | | |

PSA: Do Your AutoLISP Programs Use the CDATE or DATE System Variables?

In AutoCAD 2017-based products, the CDATE and DATE system variables no longer store the current time down to the current millisecond which if you are getting the current date or time might not be a deal breaker for your custom programs.  However, the CDATE system variables are also used to determine how long it takes for a custom program to run or to generate unique block names/entries in a log file.

If you are using these system variables, make sure your programs don't rely on time intervals as small as milliseconds.  If your custom programs do rely on milliseconds, chances are your custom programs might not be functioning as expected or could be taking longer than they did in previous releases if you are using a loop to wait for a detectable time change.

When working with time intervals as small as milliseconds, consider looking at the MILLISECS system variable.  The MILLISECS system variable returns the time difference in which the workstation was booted until now in milliseconds.  Using the MILLISECS system variable, you could get the last 2 or 3 digits of the value and append them to the value returned by the CDATE system variable if you want a value that is comparable to that returned in AutoCAD 2016-based products and earlier.  However, if you are just tracking time differences, you might just want to migrate to using the MILLISECS system variable instead of the CDATE system variable.

Sample Code

The following is an example of a custom function named CDATE that returns the values of the MILLISECS and CDATE system variables based on the release of AutoCAD being used.  The function returns the value of the CDATE system variable when executed on AutoCAD 2016-based products and earlier, and returns a value that combines the values of the CDATE and MILLISECS system variables when executed on AutoCAD 2017.

; Returns a CDATE value that includes milliseconds based on release
; Usage: (CDate)
; Replaces (rtos (getvar "CDATE") 2 8)
(defun CDate ( / ms)
  ; Check to see which AutoCAd release is being used
  (if (< (atof (getvar "ACADVER")) 21.0)
    (rtos (getvar "CDATE") 2 8)
    (progn
      ; Get the current milliseconds and append it to the CDATE value
      (setq ms (itoa (getvar "MILLISECS")))
      (strcat (rtos (getvar "CDATE") 2 6)(substr ms (- (strlen ms) 2)))
    )
  )
)

Hope this helps you understand what might need to be changed with your custom programs and how you might go about making the change.

Other related articles:

Sincerely,
  Lee

Posted at 04:00 PM in AutoCAD, AutoCAD based products, AutoLISP/Visual LISP, Programming | | Comments (2)

| | | Pin It! | | |

Getting the Current Date/Time with AutoLISP - Part 1

Needing to populate a title block or stamp a drawing with the current date/time is a very common task in the AutoCAD product along with determining the time it might have taken to execute a custom program for return of investment (ROI) analysis.  AutoCAD-based products support several system variables that can be used to determine the current date/time, these system variables are:

  • CDATE - Stores the current date and time as a decimal value.
  • DATE - Stores the current date and time in Modified Julian Date format.
  • MILLISECS - Stores the current number of milliseconds since the computer was booted.

NOTE: Starting with AutoCAD 2017, the CDATE and DATE system variables no longer store the current time down to milliseconds.

CDATE System Variable

The CDATE system variable is the most common approach to getting the current date and time within the AutoCAD environment while using AutoLISP.  When queried, the CDATE system variable returns a value as a real number.  The GETVAR function is used to return the value of a system variable for use with the AutoLISP programming language.

Here is an example of getting the value stored in the CDATE system variable:

Command: (getvar "CDATE")
2.01702e+07

As previously mentioned, the value of the CDATE system variable is a real number.  By default, it isn't possible to see the full value of the CDATE system variable without a bit of extra help.  It is best to convert the real number to a string, so you can see and work with the full value which can be accomplished using the RTOS function.  The RTOS function accepts 3 arguments, the real number to convert to a string and two optional arguments which represent the linear unit mode and precision in which the value should be formatted.

Here is an example of converting the value stored in the CDATE system variable to a string that represents the real value as a decimal with a precision of 6:

Command: (rtos (getvar "CDATE") 2 6)
"20170214.090919"

NOTE: Prior to AutoCAD 2017-based products, using a precision of 8 would include milliseconds.  Starting with AutoCAD 2017-based products, the last two places that represent milliseconds are returned as "00".

The string returned by the RTOS function in the previous example allows you to see the full real number.  The whole number prior to the decimal represents the current date while the fraction represents the current time.

Date - 20170214
Time - 090919

Year - 2017
Month - 02
Date - 14

Hours - 09
Minutes - 09
Seconds - 19

Formatting the CDATE Value with AutoLISP

This code sample demonstrates how to pull the string apart that is returned by the RTOS function into the current Month, Day, Year, Hours, Minutes, and Seconds:

; Prints or outputs the current date and time
; bOutput = T - Output the string to the Command prompt
; bOutput = nil - Return a formatted string MM/DD/YYYY  HH:MM:SS
; Usage: (CurDate T)
; Usage: (CurDate nil)
(defun CurDate (bOuput / cdate_val YYYY M D HH MM SS)
  ; Get the current date/time
  (setq cdate_val (rtos (getvar "CDATE") 2 6))

  ; Break up the string into its separate parts
  (setq YYYY (substr cdate_val 1 4)
        M    (substr cdate_val 5 2)
        D    (substr cdate_val 7 2)
        HH   (substr cdate_val 10 2)
        MM   (substr cdate_val 12 2)
        SS   (substr cdate_val 14 2)
  )

  ; Output the current date and time to the Command
  ; prompt or return the formatted output as a string
  (if bOuput
    (progn
      (prompt (strcat "\nDate: " M "/" D "/" YYYY
                      "\nTime: " HH ":" MM ":" SS
              )
      )
      (princ)
    )
    (strcat M "/" D "/" YYYY "  " HH ":" MM ":" SS)
  )
)

The output that is generated from the CurDate function will look similar to the following:

(CurDate T)

Date: 02/14/2017
Time: 14:38:57

(CurDate nil)

"02/14/2017  14:39:04"

Hope this article gives you a better understanding of how the value of the CDATE system variable can be used to get and format the current date with AutoLISP.

Other related articles:

Sincerely,
  Lee

Posted at 02:49 PM in AutoCAD, AutoCAD based products, AutoLISP/Visual LISP, Programming | | Comments (0)

| | | Pin It! | | |

Next »
My Photo

My Other Accounts

Subscribe to this blog's feed

Search

Twitter Updates

    follow me on Twitter

    Recent Posts

    Recent Comments