AutoLISP for Absolute Beginners

AutoLISP for Absolute Beginners Let us learn AutoLISP in plain English. You will be guided slowly to create your own AutoLISP program

Your First AutoLISP Program: Zoom to Origin November 17, 2010 By Edwin Prakoso 2 Comments and 0 Reactions AutoLISP has been a popular customization for AutoCAD. Many people use it to extend AutoCAD capabilities, do things that vanilla AutoCAD can’t. AutoLISP can also be useful to automate several process that usually need you use several tools, but with AutoLISP you may only need a few clicks. I’m not good with AutoLISP, but if you are interested to learn it with we, you can keep reading this tutorial. If you are an AutoLISP guru, I will be happy if you correct any mistakes or if you suggest better solution. So let us start to learn slowly, by creating simple program. You can also refer to AfraLISP for more AutoLISP tutorial. It’s an excellent resource!

Creating AutoLISP Application An AutoLISP program can be created in notepad. It is a plain text, you only have to save it with file extension .lsp. However, AutoCAD itself has provided a Visual LISP editor. There are many functionalities you can use here, more useful than notepad. Let us use visual lisp editor instead of notepad. You can access visual lisp editor from manage tab, applications panel.

AutoCAD will open visual lisp window. This window might not look fancy, and and the icons remind me of good old Windows 3.1 icons. However, it has many specific AutoLISP programming tools that can help us.

Click new or access file>new to create a new AutoLISP program.

AutoLISP Structure Before we start, let us see the common program structure below.

(defun c:YourProgramCommand () WhateverYouWantAutoCADtoDo (princ) )

Define a Function (defun ()) AutoLISP will start with (defun c:ProgramCommand ()). Defun stands for define for a function. If you find this: (defun c:ZO ()) It means that we are defining ZO as a command. AutoCAD will run your program when you type ZO then enter at command line.

Most programmer will put the close parenthesis below, parallel to open parenthesis. This will be easier for us to find the parenthesis pair. Most programming language will not care where is the close parenthesis, as long as they can find it. So make sure it will be EASY FOR YOU to find it. Inside the parenthesis, you define whatever you want AutoCAD to do. That is the tricky part. We will do a simple exercise here, to see how it works.

Your First AutoLISP Program: Zoom to Origin We are going to create our very first program. This program will zoom to the drawing srcin, no matter which part of drawing we currently see. AutoCAD tool that can do this is zoom to center. Examine what we do when we use the command.

Command: ‘_zoom Specify corner of window, enter a scale factor (nX or nXP), or [All/Center/Dynamic/Extents/Previous/Scale/Window/Object] : _c Specify center point: 0,0 Enter magnification or height <1753.5398>: 2000

The red fonts are the command we input during the zoom process. This is what we do manually: 1. 2. 3. 4.

First, we type _zoom to activate the zoom tool. Then AutoCAD will ask us which method you want to use. We type _c to use zoom center. Then AutoCAD will ask us the center point. Because we want to zoom to srcin, we type 0,0. The last thing AutoCAD will ask is the magnification. Type the distance you want to see on your screen. I use 2000. It means AutoCAD will show 1000 to the left, and 1000 to the right. With 0,0 at the screen center. If you use imperial, you may want to change it to smaller number.

Each time we give the input, we press enter. So we type _zoom [enter] _c [enter] 0,0 [enter] 2000 [enter]. Now in your Visual LISP editor, try to type like below. Type it, do not copy and then paste it. It will not work. (defun c:ZO () (command “_ZOOM” “_C” “0,0″ “2000″) (princ) ) You know what’s written in red means right? Command will load internal AutoCAD command, then you give the parameters. Each input in quote. This time, you can use (princ) or not using it. Adding (princ) will end the program gracefully, but without it, it will also work. Now save this program.

Load and Run Your Program In visual LISP editor, click load active edit window.

Now move to AutoCAD window, and try to type ZO then [enter]. Does it work? Congratulations! You have just created your first program! We will modify this program further. So save it and don’t loose it.

Using AutoLISP Variable and Asking User Input November 24, 2010 By Edwin Prakoso 0 Comments and 0 Reactions We have started the AutoLISP tutorial by creating a very simple program: zoom to srcin . That program works, but it is very limited to zoom to 0,0,0 coordinate only. We will add more functionalities so users can pick other point to zoom to. Because we will enable users to pick their own point, zoom to srcin may not appropriate name anymore. So I changed the name to Zoom to Point (ZP). Remember to type ZP then [enter] to run it after this.

Visual LISP Editor Again, you basically can use notepad, or notepad ++ to create AutoLISP program. However, Visual LISP editor can be very handy to find errors when our application become more complex. If you want to learn more about it, you can read visual lisp tutorial on AfraLISP, which is very good. I will not cover about it, at least now, and focus more on how you can write the routines.

Using Variables In programming, we use variables to save our values. In our previous sample, we haven’t use it. (command "_ZOOM" "_C" "0,0" "2000") Let’s say we save the coordinate to ZPT (zoom point) and save the magnification to MRAT (magnification ratio), then our program will be like this. (command "_ZOOM" "_C" ZPT MRAT)

Remember, the program name and user variables have to be unique and not using AutoCAD system variables. You can use any other names that can be easily recognized.

So how to tell AutoCAD the variables value? You can assign the value to variables using setq function. To set the ZPT value and MRAT value, we add these following lines before our command. (setq ZPT '(0 0)) (setq MRAT 2000)

Now let’s put it all together in our program. Now our program become like this. (defun c:ZP () (setq ZPT '(0 0)) (setq MRAT 2000) (command "_ZOOM" "_C" ZPT MRAT) (princ) )

Try to type it in your visual LISP editor and try it. Load the program, and run it. Does it work?

Asking for User Input Now we are going to ask the user to define their point. Change the 0,0 coordinate to this code: (setq ZPT (getpoint)) Now load the application again, then try to activate it again. It works, doesn’t it? But there is one thing left. We both know that the program want us to click a point, but there is no instruction what should we do. If we give the program to other people, they will be confused! So let’s fix the code.

(setq (getpoint Pick aZPT point or type "coordinate: ") Load and try again. Nice… isn’t it?

Defining Local Variables Let us move to AutoCAD. In AutoCAD command line, type !ZPT. The exclamation mark in front of the variable name will show you the variable value. If you haven’t run the program, it should mention nil. Or it doesn’t have a value. If you have run it before, it will show the last coordinate you pi cked. It means that AutoCAD remember the value and use your computer resource. It probably doesn’t matter because we only have one AutoLISP program running and only has 2 variables. But when you already have dozens of AutoLISP program running with many variables, it may affect your machine’s performance. You may want to leave the value as global variable if you do want to use it in other program. But if you are not, it is a good idea to set it as a local variable. Close your drawing, and create or open a new drawing. Type ZP then [enter] to test if your program hasn’t loaded yet. It should say: Unknown command “ZP”. Press F1 for help. If it’s not, close AutoCAD and open it again. Do not load your program for now. Open Visual LISP editor. In defun line, modify it to this. (defun c:ZP (/ ZPT MRAT)

Now load your program. After you run it, type !ZPT or !MRAT to see the variable value. Now they should say nil. Now AutoCAD doesn’t keep the variable in your computer memory after the program has finished running.

Giving Comments Most AutoLISP program have comments. The idea is to give information when other people open the program, what it does, who create it, and you can also add some information what the codes in a line does. Comments will be ignored by AutoCAD, and will not be processed. Let us complete it so it would looks like a real program. You can give comments to your AutoLISP program using semicolon character. I added some comments like below. Now you can see how the pretty colors can easily distinguish the codes right? See what the colors mean in this AfraLISP tutorial.

If you have a problem with the code, try to copy the completed code below, and paste in your Visual LISP editor. ;Zoom to Point ;This program will quickly zoom to a specific point ;Created by: Edwin Prakoso ;website: http://cad-notes.com (defun c:ZP (/ ZPT MRAT) (setq ZPT (getpoint " Pick a point or type coordinate: ")) ;this will ask for user input (setq MRAT 2000) (command "_ZOOM" "_C" ZPT MRAT) ; this will run the zoom command (princ) )

Using AutoLISP Program to label point coordinate November 25, 2010 By Edwin Prakoso 8 Comments and 0 Reactions I have posted an AutoCAD tip how you can create your own label coordinate in AutoCAD using block attributes. It is nice that you can create your own block, create your own block shapes, and customize it to look anything you want to. But there is a limitation. It will only recognize the point position from global coordinate. If you move the UCS, it will still use global coordinate. It makes sense, because if we want to label our coordinate, then usually we do use global coordinate. But what if you want to label the coordinate from UCS? Because I’m currently learning AutoLISP, then I decided to take it as a challenge to create a program to do that. You can download the file in link you’ll find below this post.

How to use the program? 1. Download the LISP file 2. Load the LISP program. There are several ways to load AutoLISP program, but this is the easiest way. Thanks Ellen! 3. I wrote the code to run when I type LB then [enter]. You should be able to use it after you load the program. 4. You need to click twice: the point you want to label and label location. 5. It will use leader command. So if it’s too large, too small, or you want to customize it, change your style. 6. It is also use file UNITS settings. If you want to change the format to decimal or architecture format, change it in UNITS settings. 7. The program will continue to ask you for points until you press [esc] or [enter]. I decide to make it this way because mostly we want to create several labels at once. So you don’t need to reactivate it after you have labeled one point. If you are following AutoLISP tutorial in CAD Notes, be patience! We will get there. Here is the code. ; Automatic coordinate labeling ; Edwin Prakoso ; http://cad-notes.com ; ; Limitation ; ---------; Will use current leader style and current units setting (defun c:lb (/ p x y ptcoord textloc) (while (setq p (getpoint " Pick Point: ")) (setq textloc (getpoint " Pick Label Location: "))

(setq x (rtos (car p))) (setq y (rtos (cadr p))) (setq z (rtos (caddr p))) (setq ptcoord (strcat x ", " y ", " z)) (command "_LEADER" p textloc "" ptcoord "") ) ) And if you want to simply download and use it, download this file. There are two files in the zip file. 1. and Y only) 2. LB.lsp LBZ.lspisisfor forLabeling LabelingCoordinate Coordinate(X(X, Y, and Z) Enjoy the LISP, and share it to your friends! Notes: After I wrote this, I realize that Shawki abo zeed have published similar code in labeling coordinate tips. It looks it has more features. If this one doesn’t work fine, you may want to try his code too. Thank you to Shawki!

Labeling Coordinate with Easting and Northing in AutoCAD November 26, 2010 By Edwin Prakoso 8 Comments and 0 Reactions After I provided AutoLISP program to label coordinate automatically, I had some questions if it can show N, E, and elevation instead of just the coordinate text. So I made minor adjustment to the code. This automatic labeling will create three lines of texts instead of just one line of xyz coordinate.

You can open notepad, copy and paste the code below, then save it as “lb.lsp” (type it with double quote when saving in notepad). If you want to show only Easting and Northing, you can delete the marked lines. Or replace East with E or X=, and so on. I hope this is useful. ; Automatic coordinate labeling ; Edwin Prakoso ; http://cad-notes.com ; ; Limitation ; ---------; Will use current leader style and current units setting ; If you don't want to show elevation, then modify lines marked * (defun c:lb (/ p x y z ptcoord textloc) (while (setq p (getpoint " Pick Point: ")) (setq textloc (getpoint " Pick Label Location: ")) (setq x (rtos (car p))) (setq y (rtos (cadr p))) (setq z (rtos (caddr p))) ;*you may delete this line (setq x (strcat "East " x)) (setq y (strcat "North " y)) (setq z (strcat "Elev. " z)) ;*you may delete this line (command "_LEADER" p textloc "" x y z "") ;*you may delete z

) ) Want to create this program by your own? You can also adjust it to your needs.

AutoLISP Exercise : Create Regular Polygon by Defining Area December 1, 2010 By Edwin Prakoso 3 Comments and 0 Reactions I hope you are having fun with our AutoLISP exercises. Last time, we were introduced to use AutoLISP variables and asking users for input. This time we will learn about asking for more user input, then using the input in mathematical equation. The calculation result will be used to draw an object. Our challenge now is to create a program that can draw a regular polygon by defining number of sides and the area. Interesting isn’t it?

Writing Calculation in AutoLISP Writing calculation in AutoLISP is quite different. But should not be difficult to understand. If we want to calculate 2+5, then we write: (+ 2 5) Let us try it in AutoCAD command line. Type in AutoCAD the line above. Yes you can use AutoLISP command in AutoCAD. You need to type it exactly like above. Now let’s try another one. Type each line then press *enter+. (setq a 2) (setq b 5) (+ a b) What we did is set variable a value to 2, b to 5, then calculate a+b. (setq c (+ a b) This one means c = a + b. Not so difficult, isn’t it? Refer to other calculation function in AfraLISP site. Now let us see the polygon formula.

Drawing Polygon Method How can we draw polygon by defining the area? I did some searches and find this formula.

source: Math Open Reference page. If we know the area and number of sides, we can calculate the apothem. What is apothem? See image below.

How can we draw a polygon when we know the apothem and number of sides? Using polygon tool of course. We create it using circumscribed method.

Calculating Apothem Length We need to change the formula to get the apothem like below:

Functions in Our Formula We will use these function in our formula. 1. square root can be written as (sqrt a), 2. multiplication as (* a b), 3. division as (/ a b), 4. cosine of an angle as (cos ang), 5. sine of an angle as (sin ang). With a, b, and ang are variables. The bad news is AutoLISP doesn’t have tan function. But there is work around. Tangen is sin/cos. Tan (pi/N) can be written as: (setq ang (/ pi N)) (/ (sin ang) (cos ang)) Pi is built in variable, so we will just use it. Besides the sequence, you should be familiar with the command. If you want to try writing the equation by yourself, go ahead. It can be a good exercise to get familiar with mathematical function in AutoLISP. You can find the equation below later.

The to complete be written. I use variable for ang areato and n for number of sides. I also use apt keep theequation equationcan value (the apothem length),aand keep (pi/n). (setq ang (/ pi n)) (setq apt (sqrt (/ (/ a (/ (sin ang) (cos ang))) n))) Or you can write in a single line, which looks more confusing. (setq apt (sqrt (/ (/ a (/ (sin(/ pi n)) (cos(/ pi n)))) n)))

Asking For User Input We already use getpoint to ask user to pick a point. Or they can type the coordinate. Now we need three user input: number of sides, area, and center point. 1. Number of sides is an integer. You don’t accept 2.5 as number of sides, don’t you? We can use GETINT to ask for integer. 2. Area can have decimal numbers, so it is a real number. We can use GETREAL for this purpose. 3. You already use GETPOINT to ask for a point right? Let us try. In AutoCAD command line, type (GETINT)

type integer number. It should return the number you entered. Try again. This time type a decimal number.Let’s say 3.2. What will AutoCAD say?

Command: (getint) 3.2 Requires an integer value.

Using the right user input function will also reduce probability of errors.

Writing the Complete Code Now we can write the complete code. 1. You need to ask the user the number of polygon sides, the expected polygon area. 2. Then you calculate the value. 3. You need to ask one more input: the polygon center. 4. Finally you can write the polygon command. Now we have complete data, what we will put in our program. I strongly suggest you to try writing the program first. You can check and compare the code later. Below is the complete code I created. If you have problem, you can copy the code below. ; This LISP will create regular polygon by defining polygon area and number of sides ; Created by Edwin Prakoso ; Website: http://cad-notes.com (defun c:pba (/ a n apt ptloc) (setq n (getint " Number of Polygon Sides: ")) (setq a (getreal " Expected Polygon Area: ")) (setq ang (/ pi n)) (setq apt (sqrt (/ (/ a (/ (sin ang) (cos ang))) n))) ;calculating apothem for circumscribed polygon (setq ptloc (getpoint " Pick Location: ")) (command "_POLYGON" n ptloc "C" apt) )

AutoLISP exercise: creating program to label coordinate December 6, 2010 By Edwin Prakoso 4 Comments and 0 Reactions In this exercise, we will continue our AutoLISP tutorial. This time we are going to use lists and strings. We have learned how to use mathematic equation in AutoLISP to calculate a value. This time we will work with strings. Let us see what are we going to create. We are going to create a program to place coordinate label for a point automatically. See the program and try it first if you want.

Program Basic We are going to use leader tool to label it. It will require us to define two points: point to label, and where we want to place the label. We already learned how to ask for user input for a point. So you should already familiar with this code: (defun c:\cnlabel () (setq p (getpoint " Pick Point to Label: ")) ; asking user to click point to label and save it (setq textloc (getpoint " Pick Text Location")) ; asking user to click text location (command "_leader" p textloc "" p "") ; activate label tool and use the input ) In visual LISP editor, you can copy or type it (I suggest you to type it for your exercise) then click load active edit window.

After you load it, type cnlabel to activate the tool.

Using Leader tool Let’s see how the leader tool works. 1. After we activate leader tool, we need to place first point. The first point will be the point we label. 2. Then it will ask next point. We are going to use text location (textloc variable) as second point. 3. It will ask for another point for the leader. If we only want one segment, we can press *enter+. To simulate *enter+ in AutoLISP, we simply use “”. 4. Next, we type the text. In AutoLISP program we can use point coordinate we get from user. 5. Leader will ask for another input for the next line. We don’t want to add next line. To finish it, we can press *enter+. Again, we simulate it using “”. This line below will do what is described above. (command "_leader" p textloc "" p "") What if you don’t want to use leader, but would like to use Multileader? Simple, use this line: (command "_mleader" p textloc p) Try to use it first if you want to know how mleader works, pay attention on each step what you should do. The program can be used, but the result is not good enough. We can’t control the text appearance, the label will be shown similar like below.

See how many decimal numbers it has?

Getting Value from The List Let us try the AutoLISP program. We haven’t define p and textloc as local variables, so the value should be still stored even after we run the program. Now after you run it once, type !p to see the p value. It should return something like this: (268.782 34.178 0.0) The value is a list. To get the x, y, and z value we can use car, cadr, and caddr. car will pick the first value from the list. So to get x value, we can do this: (car p) To save the value to x, we continue the line like this. (setq x (car p)) cadr will get the second value from the list, caddr will get the third value from the list. To separate all the values, we can write lines as below: (setq x (car p)) (setq y (cadr p)) (setq z (caddr p)) When we work on 2D drawings, we don’t need to use z value, so you can delete the last line. Unless you work in 3D.

Converting Real to String We already get the x and y value, but they are still in real number. If we want to add more text, like x=…, y=… then we need to convert them to string. We can convert them to string using rtos function. Let us add it to our code.

(setq x (rtos (car p))) (setq y (rtos (cadr p))) Now x and y are strings. We can add more texts to those strings. In calculating real or integer, we can use mathematic function like + or –. But in strings, we use strcat to add more text to the variable. Let say I want it to look like this: x = 100, y = 50

I can create it by combining x and y like this: (setq ptcoord (strcat “x= ” x “; ” “y= “ y)) Don’t forget to save it to a variable! I use ptcoord. You may change the text inside the double quotes. You may want to use E=…, N=…, el=… etc. Now let’s put it all together:

(defun (setq p c:cnlabel (getpoint()" Pick Point to Label: ")) (setq textloc (getpoint " Pick Text Location")) (setq x (rtos (car p))) (setq y (rtos (cadr p))) (setq ptcoord (strcat "x=" x ", " "y=" y)) (command "_leader" p textloc "" ptcoord "") (princ) )

Tips: Seeing Dynamic Lines from Previous Point

One annoying thing about this program is we can’t see dynamic line when we place the second point. Just like when we place a leader or even a simple line.

To add the dynamic line, we simply add the variable of the first point when we ask the second point. The variable is p, so now the line become: (setq textloc (getpoint p ” Pick Text Location”)) Add it and try it again.

More Tips: Adding a Loop to Keep the Program Active When we use line tool, the tool will be still active until we press [esc] or [enter]. Some other tools also have the same behavior. The idea is we can keep using it and don’t have to reactivate it when we still want to use it. Because when labeling coordinate we usually need to label several points, we can make this program to behave the same. To do this, we can add a loop with (while). So the complete program will be like this. (defun c:cnlabel (/ p x y ptcoord textloc) (while ;start while (setq p (getpoint " Pick Point to Label: ")) (setq textloc (getpoint p " Pick Text Location")) (setq x (rtos (car p))) (setq y (rtos (cadr p))) (setq ptcoord (strcat "x=" x ", " "y=" y)) (command "_leader" p textloc "" ptcoord "") (princ) ) ;end while ) We will cover more about loop, but now this will do. Now try it. I’m amazed how many thing I can do with a basic knowledge of AutoLISP, and I believe many more things can be done. I would like to know what program have you made until this point? Please share with us!

AutoLISP Exercise: Using Block and Conditional If December 13, 2010 By Edwin Prakoso This time we are going to work with AutoCAD block. We had a good time when creating label for coordinate. Now we are going to create a similar AutoLISP program. We will create a program to label elevation. But this time we will also use block. Using block has several advantages. We can have more geometries without having to draw them and also can place the text to block attributes.

Before We Start: Preparing the Block File Before we start, you need to download this AutoCAD file. This is the block we are going to use as elevation label.

Save the file to your library folder. I save it to D:\acadlib. You may have different location if you want to. Now we need to set the location as AutoCAD support file search path. Open AutoCAD option. Add the folder location here.

Command We will Use Easy enough to guess: we are going to use INSERT to insert our block. If you try to type INSERT then [enter] in AutoCAD, it will open insert dialog box. That will not work with our AutoLISP program. AutoLISP will only work if we give input in command line or without dialog box.

To prevent AutoCAD to load the dialog box, we need to add – (dash) in front of the command. try to type –INSERT then *enter+. See what I’m talking about?

We are going to use that. Insert block will insert a block with the name we defined in our AutoLISP program. If it can’t find it, then it will search and load DWG name with the same name as the block. Then insert the DWG as block. That is why we define the file location in default search path. AutoCAD will load the file from that location. The rest is easy. Like in previous tutorial, we can get the elevation value from the coordinate list and insert it to the block attribute. So our basic program can be like this: (defun c:cnannolevel (/ labelposition y) (setq labelposition (getpoint " Pick Label Position: ")) (setq y (cadr labelposition)) (setq y (rtos y)) (command "_-insert" "annolevel" labelposition 1 1 0 y) )

More Consideration If you already tried it, you can see it works nicely. But you may want to consider to allow AutoCAD users to change the block scale. We will do it later in this AutoLISP tutorial. The next thing is change the label value when it’s at 0 elevation. In my country, many people like to use+ 0.00 when it’s at zero elevation. We will add an if conditional to change the value.

Add Ability to Change Scale If you examine the block, you will soon know that it was created in full scale 1:1. When you need to place it to a drawing with 1:100 scale, then you need to scale it after placing it. We don’t want that, don’t we? So now we will add one more variable. This time we will let the variable become global variable. So AutoCAD will still recognize the variable after the application ends. And we can use it for other LISP application. Because we don’t want the program to ask user for scale every time they use it, then we will use conditional IF. The structure of conditional IF is

(IF (statement) (things to do if true) (else, things to do if false)) I added conditional IF twice: (if (= cnglobalscale nil) (setq cnglobalscale (getreal " Set Global Scale for CN Annotation <1/1>: ")) ) (if (= cnglobalscale nil) (setq cnglobalscale 1) )

The code in plain English 1. The first conditional will check if the globalscale is not set (the value is NIL). If it’s true it will ask the user for input. 2. The second conditional will check if the user don’t give any input and simply press *enter+. Because the user don’t provide value, then the scale still NIL.We assume that they want to use default scale 1:1. That’s why we provide 1/1 in the bracket. We tell user that if they don’t give any value, it will use full scale. This is common in AutoCAD tools to offer user to use default value. Now the program become like this: (defun c:cnannolevel (/ labelposition y) (if (= cnglobalscale (setq cnglobalscale nil) (getreal " Set Global Scale for CN Annotation <1/1>: ")) ) (if (= cnglobalscale nil) (setq cnglobalscale 1) ) (setq labelposition (getpoint " Pick Label Position: ")) (setq y (cadr labelposition)) (setq y (rtos y)) (command "_-insert" "annolevel" labelposition cnglobalscale cnglobalscale 0 y) ) (defun c:cnannoscale () (setq cnglobalscale (getreal " Set Global Scale for CN Annotation: ")) ) I added one more function at the bottom so users can change the scale anytime. Remember, we only ask for scale one time, when the global scale is NIL. So we need to provide them a way to change the scale manually later.

Change Text in Zero Elevation As I mentioned before, we here would like to have + 0.00 than just 0 at zero level. This is simple. Just like before, we use conditional IF. Instead of using (setq y (rtos y)) We use (if (= y 0) (setq y "%%p 0.00") (setq y (rtos y))) The code will check if Y value is zero, and replace it with + 0.00. If it’s not, it will use the srcinal value.

Final Code After we added those features, then this is the complete code: ; CAD-Notes.com annotation utilities ; by: Edwin Prakoso (defun c:cnannolevel (/ labelposition y) (if (= cnglobalscale nil) ; this will check if user already has defined the drawing scale (setq cnglobalscale (getreal " Set Global Scale for CN Annotation <1/1>: ")) ) (if (= cnglobalscale nil) ; this will check if the user choose default value (setq cnglobalscale 1) ) (setq labelposition (getpoint " Pick Label Position: ")) (setq y (cadr labelposition)) (if (= y 0) (setq y "%%p 0.00") (setq y (rtos y))) ; this will change text when in zero elevation (command "_-insert" "annolevel" labelposition cnglobalscale cnglobalscale 0 y) (princ) ) (defun c:cnannoscale () ; this" another function defined to enable user to change scale later (setq cnglobalscale (getreal Set Global Scale for CN Annotation: ")) ) This program works nice. But the problem is the label can’t be updated automatically. Not like using fields. We will cover how to update the value later when we cover entity selection.

AutoLISP tutorial: system variable and conditional COND January 24, 2011 By Edwin Prakoso 0 Comments and 0 Reactions In the last AutoLISP tutorial, we have tried to place block and change the attribute value. We also use conditional IF. Using AutoCAD block in AutoLISP is a great benefit. We can use our reusable content to make AutLISP programming less complex, and we can maintain our drawing standard in AutoCAD. This time we will try to use another conditional, using COND. We will also touch AutoCAD system variables, one of the most important thing in AutoLISP.

The program we will make in this AutoLISP tutorial will draw grid line, and automatically place label at the end of line. Before you start, you need to download this file first. The zip file has 4 AutoCAD DWG files, each file is a grid label for each direction. We will use conditional COND to choose which AutoCAD block we should use. This AutoLISP tutorial requires you to understand what we did previously. So if you haven’t read it or want to refresh your memory, read the AutoLISP tutorial so far above. Or if you completely new to AutoLISP, follow this tutorial from beginning.

Using Conditional COND COND is a bit different with IF. When using IF, you can tell AutoCAD to do A when condition is met. Or else, do B. COND will only do things when the condition is met. The basic of using COND is: (cond ((condition a) (things to do when condition a is met) ((condition b) (things to do when condition b is met) ((condition c) (things to do when condition c is met) and so on…

) Let’s see what can we do with COND in our case. (cond ((AND (= pt1x pt2x) (> pt1y pt2y)) (setq gridblockname "vgridbottom")) ;change block name when meet the condition ((AND (= pt1x pt2x) (< pt1y pt2y)) (setq gridblockname "vgridtop")) ((AND (> pt1x pt2x) (= pt1y pt2y)) (setq gridblockname "hgridleft")) ) First, we set the block name to HGRIDRIGHT. We will use this block when we draw grid line to the right. But when we draw it to bottom, we need to use block VGRIDBOTTOM. When we draw a grid to bottom, there are two conditions are met: 1. X1 and X2 are the same. 2. Y2 is larger than Y1. X1, Y1 is the first picked point, and X2, Y2 is the 2nd point picked by user. We define the three conditions in our program. For right direction, we don’t have to define it because we already set it as default block name.

Changing AutoCAD system variable Another thing we need to do is change an AutoCAD system variable temporarily. We can do it in AutoLISP using SETVAR. We want to create the grid horizontal or vertical. To achieve that, we need to draw line with ortho mode is on. This behavior is controlled by system variable ORTHOMODE. We need to change it to 1 to make ortho mode active. But before we change it, it is a good thing to restore the system variable after the program ends. We don’t want the program to change our AutoCAD behavior and we need to change option every time we use the program. We need to save the current ortho mode first to a temporary variable. We can get the system variable and save it to user variable in AutoLISP using GETVAR. (setq CurrentOrthomode (getvar "orthomode")) (setvar "orthomode" 1) The first line will get the system variable and save it to variable CurrentOrthomode. OK, if you feel the variable name is ridiculously long, you can choose your own name :) The second line, we set ORTHOMODE system variable to 1. After our AutoLISP program ends, we can restore the system variable to the srcinal value. (setvar "orthomode" CurrentOrthomode)

The complete AutoLISP program Now we have everything we need. The AutoLISP program will run like this: 1. 2. 3. 4.

It will check the drawing scale. Refer to previous tutorial to see how it works. It will save the current orthomode and change orthomode to 1. It will ask user to place two points for the grid. It will check which it should use.

5. It will draw grid line and insert the block. 6. It will restore the orthomode. The complete AutoLISP code is like this: (defun c:cngrid (/ pt1) (if (= cnglobalscale nil) (c:cnannoscale) ) ; end if (setq CurrentOrthomode (getvar "orthomode")) (setvar "orthomode" 1) (setq pt1 (getpoint " Pick Grid Start Point: ")) (setq pt2 (getpoint pt1 "nPick Grid Last Point: ")) (setq pt1x (car pt1))(setq pt1y (cadr pt1)) (setq gridblockname pt2x (car pt2))(setq pt2y (cadr pt2)) (setq "hgridright") ;set default grid name (cond ((AND (= pt1x pt2x) (> pt1y pt2y)) (setq gridblockname "vgridbottom")) ;change grid name when meet the condition ((AND (= pt1x pt2x) (< pt1y pt2y)) (setq gridblockname "vgridtop")) ((AND (> pt1x pt2x) (= pt1y pt2y)) (setq gridblockname "hgridleft")) ) (setq gridnumber (getstring " Enter Grid Number: ")) (command "_line" pt1 pt2 "") (command "_-insert" gridblockname pt2 cnglobalscale cnglobalscale 0 gridnumber) (setvar "orthomode" CurrentOrthomode) (princ) ) (defun c:cnannoscale () ; this another function defined to enable user to change scale later (setq cnglobalscale (getreal " Set Global Scale for CN Annotation <1/1>: ")) (if (= cnglobalscale nil) ; this will check if the user choose default value (setq cnglobalscale 1) ) ; end if )

Error trapping To complete this AutoLISP program, it is a good thing that you create an error trapping. We change an AutoCAD system variable: ORTHOMODE. We do set it back to srcinal value. The problem is, when an error occur and the program ends prematurely, the system variable is not restored. The variable will not be restored when you press esc key! This is what happen in this selection issue and the missing dialog box. Many problem can happen if you don’t set error trapping in an AutoLISP program!

Adding New Line in Multiline text March 11, 2011 By Edwin Prakoso We created an AutoLISP program to create leader to label coordinate before. It will be very useful for surveyors who use vanilla AutoCAD. But you may want to use multileader instead of leader in your AutoLISP program. MLEADER is neat, and you can have more control and flexibility with it. The problem is it uses multiline text, not single line text in leader. When working with multiline text, we press [enter] when we want to add another text line. But using “” in AutoLISP to simulate pressing enter, it will not work. When we use “” AutoCAD thinks we want to end the command. But not adding new line. I posted a reply in the comment section, but just in case you miss it I write it as a post. To solve this, we need to use ANSI character to add a new line. chr 10 will add new line (or line feed) to our variable. Let’s take an example. We add that character to our string variable: (setq ptcoordN (strcat "N=" y)) (setq ptcoordE (strcat "E=" x)) (setq ptcoordN (strcat ptcoordN (chr 10) ptcoordE)) The first and second line will get x and y value, then add prefix. The 3rd line will combine them both. Thatcomplete AutoLISP AutoLISP code will code combine N coordinate, new line, then place E coordinate there. The will be: (defun c:cnlabel (/ p x y ptcoordN ptcoordE textloc oldprec) (setq oldprec (getvar "LUPREC")) (setvar "LUPREC" 4) (while ; start while loop (setq p (getpoint " Pick Point to Label:")) ; asking user to click point to label and save it (setq textloc (getpoint p " Pick Text Location:")) ;asking user to click text location (setq x (rtos (car p))) (setq y (rtos (cadr p))) (setq ptcoordN (strcat "N=" y)) (setq ptcoordE (strcat "E=" x)) (setq ptcoordN (strcat ptcoordN (chr 10) ptcoordE)) (command "mleader" p textloc ptcoordN) ;ativate label command and use the input (setvar "LUPREC" oldprec) (princ) ) ) I don’t know if there is other solution for this. If you know the other w ay, please share it here!

AutoLISP tutorial: Working with layers April 21, 2011 By Edwin Prakoso An AutoLISP program doesn’t have to be difficult. We can create simple LISP program and get many benefits from it. It’s not just about speed up the drawing creation, but also to maintain our standard. In system variable and COND conditional, we discussed how we can use block to create grids. This will ensure the users (or you) to use the same block for every drawing. Now let’s see how to control the other properties you need to control: layers and styles. Let’s explore the possibility to use it to control our drawing standard.

Working with layers

Layers are the most important thing to manage our drawings. If you’re not familiar with layer standard, CADD manager has a short article about the concept.

Changing the current layer We can change the current layer using setvar. We did it this previously. Current layer variable is controlled by CLAYER. (setvar "CLAYER" "LAYERNAME")

Sample: creating text Now let’s try an example. We want to create a LISP program to create text, and use a default layer. This is what we do: 1. Get current layer and save it to a variable. 2. Set current layer to a different layer. In this sample, annotation layer. 3. We ask for required data for creating text. In this sample we ask for text content and position. You may want to consider ask for height and rotation angle. But it’s not necessary in this sample. 4. Set the current layer to previous layer. This is the code after we put it all together: (defun c:cntext () (setq oldlayer (getvar "CLAYER")) ; get current layer (setvar "CLAYER" "A-Anno") ; change layer to annotation layer (setq textcontent (getstring " Type Text: ")) (setq textloc (getpoint " Text Position: ")) (command "_TEXT" textloc "" "" textcontent) ;create the text (setvar "CLAYER" oldlayer) ;restore active layer )

Check for existing layer It should works. But we still have a problem. What if the layer doesn’t exist? AutoCAD returns error warning.

; error: AutoCAD variable setting rejected: “clayer” “layername”

We need to check if the layer exist or not first. We can do it by using this code: (setq flag (tblsearch "LAYER" "A-Anno")) Then add conditional IF like this: (if flag (PUT WHAT YOU WANT AUTOCAD TO DO HERE) (ELSE DO THIS) ) We have discussed about using conditional IF in AutoLISP before. The problem is IF only allows you to run one statement. So we need to add (progn GROUP OF STATEMENTS) to run several statements.

Let’s see the complete code below: (defun c:cntext () (setq flag (tblsearch "LAYER" "A-Anno")) ;looking for A-Anno layer ;then do this if exist (if flag (progn ;grouping statement (setq oldlayer (getvar "CLAYER")) (setvar "CLAYER" "A-Anno") (setq textcontent (getstring " Type Text: ")) (setq textloc (getpoint " Text Position: ")) (command "_TEXT" textloc "" "" textcontent) (setvar "CLAYER" oldlayer) ) ;end statement group ;else - and give warning if it doesn't exist (alert "No A-Anno layer. Create it first to maintain standard.") ) ; end if ) Now AutoCAD will try to find the layer first before executing our command. If it doesn’t exist, then it will give a warning.

If the layer exists, then it will run our program. There are several possibilities to handle this situation. We will see in the next tutorial, other alternatives to deal with non-exist layers.

Creating layer and styles with AutoLISP May 27, 2011 By Edwin Prakoso We learned how we can work with layers when we create objects in our AutoLISP program. By changing current layer or style in the program, it will make sure our objects to use specific properties. For example, we want when we place the grid label, we place it on annotation layer. This is a good way to be implemented with your company standard. But what we did before is simply change it. If it doesn’t find it in name list, it simply gives a warning. Ask the user to create it first. That’s not cool. The more logical thing to do is, when it doesn’t find it, it creates a new one.

Creating a new layer Creating new one is easy. We use LAYER command. Type –layer on command prompt. You will see the list of available options. Remember, you can check the command we can use at command line first. Use – (dash) to load the command without dialog box. That’s how we use it with AutoLISP.

Command: -layer Current layer: “0″ Enter an option [?/Make/Set/New/Rename/ON/OFF/Color/Ltype/LWeight/TRansparency/MATerial/Plot/Fre eze/Thaw/LOck/Unlock/stAte/Description/rEconcile]: m Enter name for new layer (becomes the current layer) <0>: newlayer Enter an option [?/Make/Set/New/Rename/ON/OFF/Color/Ltype/LWeight/TRansparency/MATerial/Plot/Fre eze/Thaw/LOck/Unlock/stAte/Description/rEconcile]: The bold text with red color is what we’re going to use in AutoLISP.

  

-Layer is the command. M will create new one, it will ask you for it’s name and then make it current. This command will keep asking you to enter an option. So we press [enter] to end the command.

So we can write it as a LISP program below: (command "_layer" "m" "NEWLAYER" "")

Easy, right? This will create new layer named NEWLAYER (if there is no newlayer in the list) and make it current. The good thing about it is, if there is existing layer with that name, it will accept it and set make it current. So we don’t have to add code to check if it already exist. We can replace this code we made before: (defun c:cntext () (setq flag (tblsearch "LAYER" "A-Anno")) ;looking for existing ;then do this if exist (if flag (progn ;grouping statement (setq oldlayer (getvar "CLAYER")) (setvar "CLAYER" "A-Anno") (setq textcontent (getstring " Type Text: ")) (setq textloc (getpoint " Text Position: ")) (command "_TEXT" textloc "" "" textcontent) (setvar "CLAYER" oldlayer) ) ;end statement group ;else - and give warning if it doesn't exist (alert "No A-Anno layer. Create it first to maintain standard.") ) ; end if )

With much simpler code like this defun c:newla () (setq oldlayer (getvar "CLAYER")) ;get the current first (command "_layer" "m" "newtest" "") ;create and change current (setq textcontent (getstring " Type Text: ")) (setq textloc (getpoint " Text Position: ")) (command "_TEXT" textloc "" "" textcontent) (setvar "CLAYER" oldlayer) )

Working with text styles and dimension styles So what about text styles and dimension styles?

Text Styles What about text styles? We can use style command. It also can create new style and use it as current. Let examine in command line how the sequence is.

Command: -STYLE Enter name of text style or [?] : newstyle New style. Specify full font name or font filename (TTF or SHX) : arial Specify height of text or [Annotative] <0.0000>: Specify width factor <1.0000>: Specify obliquing angle <0>: Display text backwards? [Yes/No] : Display text upside-down? [Yes/No] : “newstyle” is now the current text style.

There are 7 options AutoCAD will ask you. Let’s see this sample. You can use this line to create text styles

(command "-style" "newstyle" "arial" "" "" "" "" "")

That code will create a new text style with name newstyle and using arial.ttf as it’s font. It ignores the other questions and accept default values only. Another example, this will create a style with height 2.5 and width factor 0.85.

(command "-style" "newstyle" "arial" 2.5 0.85 0 "N" "N")

* Note: if you use shx font, you need to press [enter] one more time. SHX fonts support vertical alignment, and AutoCAD will ask one more question, if you want to make it vertical.

Dimension Styles Unfortunately when working with dimstyle, we need to use conditional IF. 1. We need to use save option in dimstyle to create a new one. 2. Or if it doesn’t exist, we need to use restore to change the current dimension style. The problem is when we use save dimstyle, and AutoCAD find it already exist, it will ask one more question. It asks us to confirm if we want to redefine the existing. So we use this code: (defun c:tst () (setq flag (tblsearch "dimstyle" "newdimstyle")) ;looking for dimstyle ;then do this if exist (if flag (command "-dimstyle" "R" "NEWDIMSTYLE") (command "-dimstyle" "S" "NEWDIMSTYLE" "") ); end if )

Changing the properties You already know how to create a text style and set it’s properties, because they’re asked when you create a new one. Next, we will cover how we can change the properties of layers and dimenion styles. So we can create it with red color, specific linetype, lineweight, etc.

Modifying objects: working with selection June 22, 2011 By Edwin Prakoso We covered several topics on how we can draw more efficiently using AutoLISP. Now it’s time to move on. We are going to learn how we can modify existing objects in our drawing. The most important thing about editing objects is to select them. As we know, After we activate an AutoCAD modification command (like move, copy, etc) AutoCAD will ask us to select object.

Saving selection to a variable The function that allow us to do this is SSGET.

Sample 1: Move to left This sample program will allow you to select object and move them 5 unit to left.

(defun c:mleft () (setq sel1 (ssget)) (command "move" sel1 "" "0,0,0" "-5,0,0") )

SSGET will save your selection to sel1 variable. Then you can add it to move command. Remember, you need to add “” to end selection. If you don’t add it, AutoCAD will continue to ask you to select object.

Sample 2: Reset properties to ByLayer One thing that can annoy us when trying to apply CAD standard, is having the objects’ properties overridden. Set to other than ByLayer. You can change object properties by using CHPROP. Then you can choose which properties you want to set to ByLayer. Try to use CHROP to understand what we’re doing below.

(defun c:rst () (setq sel1 (ssget)) (command "CHPROP" sel1 "" "COLOR" "BYLAYER" "LWEIGHT" "BYLAYER" "LTYPE" "BYLAYER" "") )

Using other selection mode Sometimes we need to select objects without asking users to give input. Or limit the method for user to use. Using the code above will let users to use AutoCAD default mode. You can use these code to select object from within the program:

(setq sel1 (ssget "w" '(0 0) '(10 10)))

That code will select all objects inside rectangular window from 0,0 to 10,10. Other code that we can use are:

setq sel1 (ssget "c" '(0 0) '(10 10)) to select object inside and touching rectangular window (crossing polygon). setq sel1 (ssget "l")) to select last object’s created. setq sel1 (ssget "p")) to select objects in previous selection. setq sel1 (ssget "x")) all objects in the drawing.

If you’re not familiar with the selection mode above, read using AutoCAD selection below. For window and crossing polygon selection, we can also ask for user’s input.

For example:

(setq pt1 (getpoint " Pick first point: ")) (setq pt2 (getpoint " Pick other corner point: ")) (setq sel1 (ssget "c" pt1 pt2))

We will expand this selection using filter. If you have a simple example that we can use in this exercise, please let me know. I will add your code here, and you will be credited. Further readings: 1. Selection sets. Good explanation by Kenny Ramage on AfraLISP. 2. Using AutoCAD selection. Here are the list how you can select objects in AutoCAD. 3. AutoLISP function list. See all LISP function that you can use to expand your LISP program.

Filter selection with selection set July 26, 2011 By Edwin Prakoso In the last tutorial, we learned how to use object selection in AutoLISP. This time we will extend the object selection by using selection filter. Using filter in AutoLISP is very similar with using AutoCAD filter. We can define which kind of object we want to select. We can define objects with specific properties to select. For example, we can create a program to run and select dimensions in drawing, and move it to annotation layer. We will create this program in this tutorial. This kind of program probably very simple, but can help you to maintain drawing standard. As we did before, we can select all object using this line.

(setq sel1 (ssget "x"))

The Object filter Now we want to select all dimensions in our drawing. To filter the selection, we can use this code: (setq sel1 (ssget "x" '((0 . "DIMENSION")))) The complete code become:

(defun c:dimla (/ sel1 CLAYER ) (setq sel1 (ssget "X" '((0 . "DIMENSION")))) ; SELECT ALL DIMENSION (setq OLDLAYER (getvar "CLAYER")) ;GET CURRENT LAYER (command "_layer" "m" "ANNO-DIMENSION" "") ;CREATE NEW LAYER (setvar "CLAYER" OLDLAYER) ; SET ACTIVE LAYER TO PREVIOUS (command "CHPROP" sel1 "" ; CHANGE DIMENSION LAYER TO NEW LAYER "LAYER" "ANNO-DIMENSION" "") );END PROGRAM

With that simple code, you can quickly find and move all dimensions to desired layer. Very useful, right? You can also modify it to allow user to check the selection visually before move dimensions to other layer.

More about selection filter Afralisp covers this material in more advanced topic. I won’t cover it further here, because they have detailed explanation about it. Go ahead, read more about conditional operators of selection filter there.

DXF code One more thing that you might want to know is the DXF code. (0 . "DIMENSION") - Using DXF code 0 allows you to define object to select by objects type. This code will only allows you to select dimensions. (8 . "ANNO-DIMENSION") - Using DXF code 8 allows you to define object to select by their layers. This code will only allows you to select objects on layer ANNO-DIMENSION. We use DXF codes with selection filters in AutoLISP. See the complete dxf associative code below

DXF Group Codes The following table gives the group code or group code range accompanied by an explanation of the group code value. In the table, "fixed" indicates that this group code always has the same purpose. The purpose of group codes that aren't fixed can vary depending on the context. Entity group codes by number :

Group Code

Description

-5

APP: persistent reactor chain

-4

APP: conditional operator (used only with ssget)

-3

APP: extended data (XDATA) sentinel (fixed)

-2

APP: entity name reference (fixed)

-1

APP: entity name. This changes each time a drawing is opened. It is never saved. (fixed)

0

Text string indicating the entity type (fixed)

1

Primary text value for an entity

2

Name (attribute tag, block name, and so on)

3-4

Other textual or name values

5

Entity handle. Text string of up to 16 hexadecimal digits (fixed)

6

Linetype name (fixed)

7

Text style name (fixed)

8

Layer name (fixed)

9

DXF: variable name identifier (used only in HEADER section of the DXF file).

10

Primary point. This is the start point of a line or text entity, center of a circle, and so on. DXF: X value of the primary point (followed by Y and Z value codes 20 and 30) APP: 3D point (list of three reals) Other points. DXF: X value of other points (followed by Y value codes 21-28 and Z value codes 31-

11-18

38) APP: 3D point (list of three reals)

20, 30

DXF: Y and Z values of the primary point

21-28, 3137

DXF: Y and Z values of other points

38

DXF: entity's elevation if nonzero. Exists only in output from versions prior to AutoCAD Release 11.

39

Entity's thickness if nonzero (fixed)

40-48

Floating-point values (text height, scale factors, and so on)

48

Linetype scale. Floating-point scalar value. Default value is defined for all entity types.

49

Repeated floating-point value. Multiple 49 groups may appear in one entity for variable-length tables (such as the dash lengths in the LTYPE table). A 7x group always appears before the first 49 group to specify the table length.

50-58

Angles (output in degrees to DXF files and radians through AutoLISP and ARX applications).

60

Entity visibility. Integer value. Absence or 0 indicates visibility; 1 indicates invisibility.

62

Color number (fixed)

66

"Entities follow" flag (fixed)

67

Space--that is, model or paper space (fixed)

68

APP: identifies whether viewport is on but fully off screen; is not active or is off.

69

APP: viewport identification number.

70-78

Integer values, such as repeat counts, flag bits, or modes

90-99

32-bit integer values

100

Subclass data marker (with derived class name as a string). Required for all objects and entity classes that are derived from another concrete class to segregate data defined by different classes in the inheritance chain for the same object. This is in addition to the requirement for DXF names for each distinct concrete class derived from ARX (see "Subclass Markers").

102

Control string, followed by "{" or "}". Similar to the xdata 1002 group code, except that when the string begins with "{", it can be followed by an arbitrary string whose interpretation is up to the application. The only other allowable control string is "}" as a group terminator. As noted before, AutoCAD does not interpret these strings except during drawing audit operations; they are for application use.

105

DIMVAR symbol table entry object handle

210

Extrusion direction (fixed). DXF: X value of extrusion direction APP: 3D extrusion direction vector

220, 230

DXF: Y and Z values of the extrusion direction

280-289

8-bit integer values

300-309

Arbitrary text strings

310-319

Arbitrary binary chunks with same representation and limits as 1004 group codes: hexadecimal strings of up to 254 characters represent data chunks of up to 127 bytes.

320-329

Arbitrary object handles. Handle values that are taken "as is." They are not translated during INSERT and XREF operations.

330-339 340-349

350-359 360-369

Soft-pointer handle. Arbitrary soft pointers to other objects within same DXF file or drawing. Translated during INSERT and XREF operations. Hard-pointer handle. Arbitrary hard pointers to other objects within same DXF file or drawing. Translated during INSERT and XREF operations. Soft-owner handle. Arbitrary soft ownership links to other objects within same DXF file or drawing. Translated during INSERT and XREF operations. Hard-owner handle. Arbitrary hard ownership links to other objects within same DXF file or drawing. Translated during INSERT and XREF operations.

999

DXF: The 999 group code indicates that the line following it is a comment string. DXFOUT does not include such groups in a DXF output file, but DXFIN honors them and ignores the comments. You can use the 999 group to include comments in a DXF file that you've edited.

1000

ASCII string (up to 255 bytes long) in extended data.

1001

Registered application name (ASCII string up to 31 bytes long) for extended data.

1002

Extended data control string ("{"or "}").

1003

Extended data layer name.

1004

Chunk of bytes (up to 127 bytes long) in extended data.

1005

Entity handle in extended data. Text string of up to 16 hexadecimal digits

1010

A point in extended data DXF: X value (followed by 1020 and 1030 groups) APP: 3D point

1011 1012

1013

A 3D world space position in extended data DXF: X value (followed by 1021 and 1031 groups) APP: 3D point A 3D world space displacement in extended data DXF: X value (followed by 1022 and 1032 groups) APP: 3D vector A 3D world space direction in extended data. DXF: X value (followed by 1022 and 1032 groups) APP: 3D vector

1020, 1030

DXF: Y and Z values of a point

1021, 1031

DXF: Y and Z values of a World space position

1022, 1032

DXF: Y and Z values of a World space displacement

1023, 1033

DXF: Y and Z values of a World space direction

1040

Extended data floating-point value.

1041

Extended data distance value.

1042

Extended data scale factor.

1070

Extended data 16-bit signed integer.

1071

Extended data 32-bit signed long.

Saving, using and managing your AutoLISP program August 5, 2011 By Edwin Prakoso

Andres Rodriguez – Fotolia.com We covered several basic AutoLISP tutorial already. You should be able to use the programs. Now it’s time to manage them in AutoCAD. This is not only for you who want to learn AutoLISP, but also for you who want to simply use AutoLISP program. We know that we can find many AutoLISP program on internet now.

Saving an AutoLISP program You may find people giving you LISP program written in code like this. In CADTutor forum, you’ll find mostly the program is given to you written in code. You need to copy the code to your clipboard (by selecting them and pressing ctrl + c).

(defun c:cnlabel (/ p x y ptcoord textloc) (while ;start while (setq p (getpoint " Pick Point to Label: ")) (setq textloc (getpoint p " Pick Text Location")) (setq x (rtos (car p))) (setq y (rtos (cadr p))) (setq ptcoord (strcat "x=" x ", " "y=" y)) (command "_leader" p textloc "" ptcoord "") (princ) ) ;end while )

You can use visual lisp editor to save it as a program. Or notepad will work. But don’t use Microsoft Word or other Word Processing program. Paste your code there. Save it as LISP program. If you use Visual LISP editor, then by default it will save your code as .lsp file. But if you use notepad, then you must define the .lsp extension when saving your file. Type “YourProgramName.lsp” (with double quote to force notepad save it as it is). Of course, change the blue text with your program name.

Save your file to a location that allow people easily access it.

Loading AutoLISP Program Now you have your LISP program. Before you can use it, you need to load it to AutoCAD. Go to AutoCAD ribbon> manage tab> applications panel. Click load application.

hint: AutoCAD veterans use APPLOAD in command line In load/unload applications dialog, browse and find your AutoLISP file you saved before. Select it and click load.

Automatically load AutoLISP program when AutoCAD start If you use your LISP program repeatedly, then you will want AutoCAD automatically load it every time it starts. So you don’t have to load it in every new AutoCAD session. To load it automatically, add the LISP program to startup suite. The cool way to do it is by dragging the file to startup suite.

The less cool way to do it is by clicking contents button below startup suite briefcase. Here you can add or remove LISP from startup suite. Just in case one day you don’t want a LISP program to load automatically anymore, you know where to remove it now, right?

Using AutoLISP program So how you can use the program? Again, if you copy it from internet, you can see on top of the program like this.

DEFUN is defining the function. In this sample, the function can be loaded by typing DIMLA in command line then press [enter]. As simple as that. What you should do next, depends on your AutoLISP program.

Placing AutoLISP in AutoCAD Interface If you’re a command line freaks, then you can stop here. However, not all of us like using command line. You may want to have it on your ribbon (well uh, or toolbar/menu if you use classic interface).

In ribbon panel/toolbar/menu Type CUI then press [enter] to load Customize User Interface dialog. Or click User Interface in customization panel.

If you’re not familiar how to create a command here, read this tutorial first. You have to make a command, change the command name and macro. The macro should be ^C^CDIMLA. Or whatever command you want to activate using this macro. ^C^C means you press esc twice to cancel all running command. After you’ve done, drag the command to ribbon panel, toolbar, or menu as you like.

In tool palettes What about tool palettes? Can we place the command there? Sure you can. You can use palettes to activate AutoLISP command too . The process is similar with adding action recorder command in this tutorial.

What we learned Now you know how to save a LISP code, load it to AutoCAD, and use it. You also know how to use AutoLISP command from ribbon/toolbar. And even using from tool palette. So how do you use AutoLISP? Do you load it automatically? And do you use command line or place it to ribbon?

How to load AutoLISP program October 14, 2011 By Edwin Prakoso Do you want to load an AutoLISP program? Here is a basic guide how to do it.

To load application If you have an AutoLISP program, you can load it by using load application in manage tab.

Or you can type APPLOAD then press [enter]. You will see load/unload applications dialog opened. Find your AutoLISP program then click load. Double-clicking the file will also load the application. This method will load your application in current session only. It means that when you close AutoCAD, then restart it, the application is no longer loaded. You have to load it again. If you use the application frequently, then you can consider to load it automatically in every AutoCAD session. You can do it by adding it to startup suite.

To add application to startup suite If you want AutoCAD to automatically load it every time you start AutoCAD, you can add it to startup suite. To add it to startup suite is easy. You can simply drag and drop the application to startup suite icon as shown below.

To remove application from startup suite To remove it from startup suite, click contents button below briefcase icon. In opened dialog box, click application you want to remove then click remove.

Drag and drop thing to add application is cool. If you notice the a dd button here, yes, it’s the other method to add application to startup suite. Click it, find your application and click open. There are some more advance technique, but I find this is the most convenient way for people who don’t know much about customization like me. There are more methods like described in AfraLISP.

Automatically execute command when open/create new file October 25, 2011 By Edwin Prakoso 0 Last week we covered about loading AutoLISP file. You learned how to load, and optionally put your LISP to startup suite. Startup suite will load LISP automatically every time you start AutoCAD. In this post, you will learn how to load AutoLISP program using acaddoc.lsp. We also had another post about excel datalink. The problem with datalink is, it’s not updated automatically. We have to update it manually. It means we may send or plot files that use old value. In this post, you will also learn how to make AutoCAD automatically update datalink when we save or plot our files. We will define our own plot and save command.

Getting started with acaddoc.lsp What is ACADDOC.LSP? In short, it’s also an AutoLISP file. The difference is, AutoCAD will execute it every time we create or open a drawing file. If you want further explanation, Jimmy Bergmark explain about ACADDOC.LSP in details below:

Instruction on the usage of AutoCAD's acaddoc.lsp (It works for other versions (2000 and later) of AutoCAD and verticals as well) AutoCAD is normally not supplied with the user-defined startup file acaddoc.lsp; you create (Notepad can be used) and maintain the file yourself. The acaddoc.lsp file is intended to be associated with each document (or drawing) initialization. This file is useful if you want to load a library of AutoLISP routines to be available every time you start a new drawing (or open an existing drawing). Each time a drawing opens, AutoCAD searches the library path for an acaddoc.lsp file. If it finds one, it loads the file into memory. The acaddoc.lsp file is always loaded with each drawing regardless of the settings for the ACADLSPASDOC and LISPINIT system variables. Most users will have a single acaddoc.lsp file for all document-based AutoLISP routines. AutoCAD searches for an acaddoc.lsp file in the order defined by the library path; therefore, with this feature, you can have a different acaddoc.lsp file in each drawing directory, which would load specific AutoLISP routines for certain types of drawings or jobs.

The acaddoc.lsp file can contain AutoLISP code for one or more routines, or just a series of load function calls. The latter method is preferable, because modification is easier. If you save the following code as an acaddoc.lsp file, the files mydocumentapp1.lsp, build.lsp, and counter.lsp are loaded every time a new document is opened. (load "mydocumentapp1") (load "build") (load "counter")

Warning! Do not modify the reservedacad2004doc.lsp, startup file acad YEAR doc.lsp (acad2000doc.lsp, acad2000idoc.lsp, acad2002doc.lsp, acad2005doc.lsp, acad2006doc.lsp, acad2007doc.lsp, acad2008doc.lsp, acad2009doc.lsp, acad2010doc.lsp, acad2011doc.lsp). Autodesk provides the acadYEARdoc.lsp file, which contains AutoLISP-defined functions that are required by AutoCAD. This file is loaded into memory immediately before the acaddoc.lsp file is loaded. acadYEARdoc.lsp Do not modify the reserved file acad YEARdoc.lsp; it contains AutoLISP-defined functions required by AutoCAD. The file acadYEARdoc.lsp is loaded into memory immediately before acaddoc.lsp.

How to create acaddoc.lsp if it does not exist In the folder where you want to save acaddoc.lsp right click and select New>Text Document. Change the name to acaddoc.lsp. Now you should be able to double click on the file and typically edit it in Notepad. Or start Notepad, edit, save, ready.

Examples on location for acaddoc.lsp C:\Program Files\AutoCAD 2008\Support C:\Documents and Settings\\Application Data\Autodesk\AutoCAD 2008\R17.1\enu\Support or in Windows Vista C:\Users\\AppData\Roaming\Autodesk\AutoCAD 2008\R17.1\enu\Support If you want to find folders that are searched by AutoCAD run the OPTIONS command and look at the Files tab and at the Support File Search Path.

Load order of files in AutoCAD Files in acad.rx acadYEAR.lsp acad.lsp acadYEARdoc.lsp acaddoc.lsp acad.dvb Partials to Main CUI/CUIX named MNLs Partials to Main CUI/CUIXloaded LSPs and MNLs in the order seen in CUI Main CUI/CUIX named MNL Main CUI/CUIX loaded LSP and MNL in the order seen in CUI

Partials to Enterprise CUI/CUIX named MNLs Partials to Enterprise CUI/CUIX loaded LSPs and MNLs in the order seen in CUI Enterprise CUI/CUIX named MNL Enterprise CUI/CUIX loaded LSP and MNL in the order seen in CUI acetmain.MNL Express Tools loaded LSP and MNL in the order seen in CUI Files in the startup suite in listed order seen in APPLOAD (S::STARTUP) called Script file started by acad.exe command line switch /b This applies to AutoCAD AutoCAD 2006, AutoCAD2000, 2007,AutoCAD AutoCAD2000i, 2008, AutoCAD AutoCAD 2002, 2009, AutoCAD AutoCAD 2004, 2010, AutoCAD AutoCAD 2005, 2011, AutoCAD 2012, AutoCAD 2013 Update related to AutoCAD 2013 SP1: AutoLISP and VBA Security Controls in AutoCAD 2013 SP1. New /nolisp Startup Switch. LISPENABLED, AUTOLOAD, AUTOLOADPATH system variable added. The acad2013.lsp and acad2013doc.lsp files will now be loaded only from their default installation folders: \Support \Support\

Creating acaddoc.lsp Create a new LISP file. You may use text editor or visual LISP editor to do it. Save it to a support file path. You may choose any existing path, or create your own support path. I would recommend you to do the later, and you can also save all your LISP file there.

Loading AutoLISP program in acaddoc.lsp You can load AutoLISP program using this line:

(LOAD "MYLISP")

This sample below will load cnlabel.lsp and zoomextend.lsp.

Loading AutoLISP command is something quite basic we can do with acaddoc.lsp. Next, we will try to define our own command here.

Undefine and define PLOT function in acaddoc.lsp In the next step, we will change how AutoCAD command work. Like we discuss before, we will change plot and save command. First, we need to undefine it.

Undefine and redefine We can undefine AutoCAD command using UNDEFINE. In AutoCAD command line, type UNDEFINE [enter] then PLOT [enter]. We just undefine plot command. Try to type plot in command line and see how AutoCAD will response.

Command: plot Unknown command “PLOT”. Press F1 for help.

After we undefine PLOT, AutoCAD will not recognize it anymore. Now try type .PLOT [enter]. Notice the dot before PLOT command. Plot command should work. The dot means we use AutoCAD built in command. After we finished, PLOT and .PLOT will give different result. The first one will use plot we define in acaddoc.lsp. The last one use AutoCAD built-in plot command.

You can activate PLOT command back using REDEFINE [enter] PLOT [enter]

Defining function in acaddoc.lsp Now let’s work with acaddoc.lsp. First we undefine PLOT, then define new command. The new plot command should update datalink before start to plot. Our code become like this:

; This line below will undefine existing PLOT command (command "undefine" "plot") ; This line below will define new PLOT command (defun c:PLOT ( ) (command "_DATALINKUPDATE" K) (initdia) (command ".plot") )

We use INITDIA to load AutoCAD plot dialog. If we don’t use INITDIA before plot, then you will not see the dialog box. You will need to setup the plot using command line.

Save this AutoLISP file. Create or open a new file then activate plot. You will see after I create a new file, our code will undefine plot. Then when we use PLOT command, it updates datalink first, then activate plot. Nice, isn’t it?

Regenerating model. AutoCAD menu utilities loaded.undefine Enter command name: plot Command: Command: Command: PLOT _DATALINKUPDATE Select an option [Update data link/Write data link] : Command: .plot

Update datalink when saving file Now we don’t have to worry when we plot files. It surely will use most updated value from excel files. But we haven’t finished. We need to make sure datalinks in our files are updated before we send them. We need to modify save and saveas command. It’s very similar with plot. You can modify them as your exercise. Discuss it here if you have problem.

How do you think acaddoc.lsp can be useful? Do you think you can make use of acaddoc.lsp? Do you prefer to load AutoLISP from startup suite or this method? And what command you want to modify? What do you want it to do? Share it here, the others might find it useful too!

Set default system variables in acaddoc.lsp January 24, 2012 By Edwin Prakoso We covered about acaddoc.lsp in AutoLISP tutorial. Acaddoc.lsp will execute commands defined in it, every time AutoCAD open a file.

What can we do with acaddoc.lsp? Now if you know you can run commands automatically when you open a file, what would you do? 1. You can load AutoLISP file automatically. 2. You can define new command. In the tutorial, we redefine PLOT command to update datalink before AutoCAD starts to plot. 3. You can run commands before you start working with your file. 4. You can set system variable before you start working. In this article, we are going to focus to the last one. I found that there are many users confused why their AutoCAD doesn’t work as usual. And they become regular questions. These are some samples of changed system variables.

Common unexpected system variables change These are several common system variables that change regularly. 1. File dialog box is missing. You have to type file path and file name from command line. It’s because FILEDIA system variable has changed. 2. AutoCAD default noun-verb selection becomes verb-noun selection. It’s because PICKFIRST system variable has changed. 3. Single document interface is activated. It’s controlled by SDI system variable. 4. And more…

There is a debate why they changed. Most people think that it was because routines in AutoLISP or other 3rd party applications. I used to be agree with it, until I saw this problem also happens in AutoCAD LT. So it remains a mystery to me.

We can force to set the variables in acaddoc.lsp Harold Reuvers reminds me that we can set those variables in acaddoc.lsp. I prefer to backup my system variables and restore them when I have problem. We can’t remember all the variables, right? However, if you have specific system variable that changes often, this is a good solution. All you need is to create an acaddoc.lsp using notepad or visual LISP editor. Just type these code:

(SETVAR "PICKFIRST" 1)

Feel free to add more lines or change system variables and values as you preferred. If you want to learn how to use Visual LISP editor, see the basic AutoLISP tutorial.

What system variables do you find change often? Do you find system variables in your AutoCAD change often? What are they?

Adding AIA standard layers with LISP September 20, 2012 By Edwin Prakoso

Standard layers is one popular topic when we talk about CAD standards. There are several standard layers available like BS 1192, AIA, ISO 12567. If you asked me, I would suggest you to keep your standard layers in AutoCAD template and standards file. However, if you’ve never created standard the layers before, it would take times to add them in your template manually. There is a bundle of AutoLISP programs that you can download and run to build the layers. You can run it, it will create the layers and you can save your template. There are four LISPs, one linetype, and one ctb plot style. You must load demo.lin linetype, before you run AIALAYERSDEMO. If you don’t, you will get error when running the LISP program. You can use AIA Monochrome.ctb as your plot style. How to load and run the AutoLISP program You will download a zip file. 1. You need to extract it first. In Windows explorer, you can select the zip file, right click then select extract all… from contextual menu. Save the files in your LISP folder. 2. After you extracted the file, you can load the AutoLISP programs. 3. After you load them, you can run the AIA layers tools by typing the commands. If you use AutoCAD 2012 or later, AutoComplete should help you. 4. It might take a while until all the layers are created.

If you are planning to adopt AIA standard layers, now you have a good tool to start using it!