Tommy’s approach is unique, I think. Instead of drawing the lines first, the AutoLISP routine prompts you for points, which are the endpoints of the lines. Here are the [...]]]>

Tommy Holder submitted a different approach to creating fillets–one that includes drawing the lines. For the earlier routine, see “Reduce mouse clicks and increase productivity with AutoLISP.”

Tommy’s approach is unique, I think. Instead of drawing the lines first, the AutoLISP routine prompts you for points, which are the endpoints of the lines. Here are the steps:

1. Download fl.lsp. FL.lsp (click to download)
2. Unzip the file.
3. Use the APPLOAD command to load fl.lsp in a location that is in AutoCAD’s support file search path.
4. On the command line, type fl and press Enter.
5. At the Enter points : prompt, specify the first line’s start point.
6. The prompt repeats, so specify the first line’s end point (which is also the second line’s start point)
7. Next, specify the second line’s endpoint and press Enter.
8. At the Enter BEND RADIUS <1.0000>: prompt, enter the fillet radius and press Enter.

Watch the video!

Tommy Holder has 35 years experience with Ingalls Shipbuilding on the Mississippi Gulf Coast where the company has built numerous ships for the Navy. He has been a CAD designer and developer, having written many lines of code, developed many menus, and trained many users. He has been a project lead and supervisor but found that his true calling was not in management but CAD development and helping users.

The number of mouse-clicks required to perform a task is generally a good indicator of productivity. The fewer the number of clicks, the less time required–hence more productivity.

In this post we will see [...]]]>

This is a guest post by Sanjay Kulkarni, an AutoCAD programmer. You can read more about him at the end of this post.

The number of mouse-clicks required to perform a task is generally a good indicator of productivity. The fewer the number of clicks, the less time required–hence more productivity.

In this post we will see an example of reducing the number of mouse-clicks, and thus improving productivity, using AutoLISP. We will use the example of the FILLET command.

Thanks to one of the blog readers Bruce Newman, who sent a problem to me. It was the source for this post.

The most simple situation where you create a fillet is when two perpendicular lines meet. Inside the FILLET command, you select the two lines (requiring 2 clicks) and AutoCAD creates the fillet.

The equivalent AutoLISP code would be

(command “fillet” (car (entsel “\nSelect the first line: “))(entsel “\nSelect the second line: “)))

This still requires two clicks.

So, the problem now reduces to finding a method to select two lines with a single click.

Before trying in AutoLISP, let’s find out if we can do it manually. There seems to be no option or a work-around to do what we want.

Luckily, we have a single point (the intersection) that is common to both lines. So, let’s explore if we can somehow use the intersection point to select the 2 lines. If you have to click only one point to select multiple objects, obviously it should be the intersection point.

Study of selection methods shows that there are two options that base their selection on two points: crossing & window. Since W must include the objects fully, it won’t be suitable. So let’s try C option.

Use the SELECT command and then the c option and click on the intersection point in response to both points. AND …….. Both lines are selected!

The equivalent AutoLISP code would be

(setq ssLines (ssget “c” (setq pt1 (getpoint “\nSelect Intersection: “) ) pt1))

Now I can use each line to create a fillet.

(command “fillet” (ssname ssLines 0) (ssname ssLines 1))

And yes … the fillet appears!

So, here is my simple program:

(defun c:FiletByPt ()

;;; creates fillet by single click

;;; ssk 110918

(setq ssLines (ssget “c” (setq pt1 (getpoint “\nSelect Intersection: “) ) pt1))

(command “fillet” (ssname ssLines 0) (ssname ssLines 1))

)

(prompt “\nCreates a fillet by single click. Type ‘FiletByPt’”)

Note: In the command name above, FiletByPt, “fillet” is intentionally spelled “filet” to avoid confusion as you start to type the custom AutoLISP command.

To use the above code, copy and paste it into Notepad and save it as filetbypt.lsp in a location that is in AutoCAD’s support file search path. Instructions for loading the program are here.

However life is always not so simple. The lines may extend beyond the intersection point. My R&D shows that the above code still works as shown in Fig. 3.

It even works when the two lines are not perpendicular.

When two lines are selected using a single point, AutoCAD finds and trims shorter segments of each line and then creates a fillet between the two remaining segments.

There might be situations (when two lines meet at the midpoint) where the code may not work or possibly needs modification.

But, if creating fillets is a major task for you, and saving 50% of time can result in significant gain, go ahead and use this code.

Are you stuck-up with such trivial tasks that are strain on your resources? Let me know and we’ll see if I can help you with useful hints or sample code.

Sanjay Kulkarni is an experienced CAD (AutoCAD, Inventor, SolidEdge, CATIA, NX) programmer and a member of the Autodesk Developer Network. He is fluent in AutoLISP, VBA, and VB.NET. He has written for AugiWORLD and Inside AutoCAD. He can be contacted at sanganaksakha@gmail.com

In the current era of globalization, many times you may have to work on drawings received from others. Sometimes, you may not be able to control the quality of the drawings you receive. [...]]]>

This is a guest post by Sanjay Kulkarni, an AutoCAD programmer. You can read more about him at the end of this post.

In the current era of globalization, many times you may have to work on drawings received from others. Sometimes, you may not be able to control the quality of the drawings you receive. In such a situation, you may have to carry out a repair job on the drawings. Such tasks can be made less tedious if you standardize these tasks and carry them out using AutoLISP.

One of my Indian clients receives drawings from their European principals. One of the repair jobs is to change the font of the text inside dimensions, attributes, tables & notes. Since all these texts are included inside their respective block, the task becomes more complicated than is really necessary.

Most of the text, however, is controlled by the text style. Thus, the job is really to change the font in the text style. But there are a handful of the text styles. So, it becomes a time consuming task.

I helped them with a simple AutoLISP function that made this job virtually painless. The function changes the association of a text style from existing font file to another font file. The function takes 2 parameters, the name of the existing text style and the name of the font file that will be associated with the text style.

You can download the function here.

How to use the AutoLISP function

This function can be used like this:

(chngFontOfTxtStyle “<TextStyleName>” “<DifferentFont.xtn>”)

As you may have noticed, this function can be used only inside another AutoLISP program. This calling AutoLISP program can provide the user interface that you may need. Following are a couple of sample situations that you can build around this function.

1. Ask the user to type the names of the text style and font file and store them in variables. Call the above function with these two variables as parameters.

2. Ask the user to type the name of the font file. Browse programmatically through all the text styles and repeatedly call the above function with name of each text style and name of the font file as parameters. This will change the font of all text styles.

As you can see, there is no limit to the situations you can build and keep using the function.

For example, you could enter the following on the command line:

(chngFontOfTxtStyle “Something Funny” “arial.ttf”)

In this case, the name of the text style is Something Funny and you want to change the font to Arial.

How to get help for the function

Also note that this function has built in help. The message is displayed as soon as you load the lisp file to type cfot? (note the use of ? to indicate help) at the command prompt. If you type this, minimal help is displayed at the command prompt.

How do you know that the font name association was successfully changed? As described in help, the function returns 0 if successful or -1 if not. You will need to check the return value.

What other tasks do you want to automate?

Are you stuck-up with such trivial tasks that are strain on your resources. Let me know directly (my email is below) and we’ll see if I can help you with useful hints or sample code. Or you can post a comment.

Sanjay Kulkarni is an experienced CAD (AutoCAD, Inventor, SolidEdge, CATIA, NX) programmer and a member of the Autodesk Developer Network. He is fluent in AutoLISP, VBA, and VB.NET. He has written for AugiWORLD and Inside AutoCAD (a monthly magazine that has since gone out of publication). He can be contacted at sanganaksakha@gmail.com

This is a guest post by Sanjay Kulkarni, an AutoCAD programmer.

Learning AutoLISP (or any other programming language) doesn’t compel you to become a programmer. You can still use it to better understand the internal working of AutoCAD and enhance your interactive working skill. This can also give you an edge over others.

Recently [...]]]>

This is a guest post by Sanjay Kulkarni, an AutoCAD programmer.

Learning AutoLISP (or any other programming language) doesn’t compel you to become a programmer. You can still use it to better understand the internal working of AutoCAD and enhance your interactive working skill. This can also give you an edge over others.

Recently I received a client’s drawing that was in AutoCAD 2004. Even when I saved it in AutoCAD 2010, the dimension would not adjust when I changed the length of a line. Only after I recreated the dimension was I able to use this capability. The reason, I found, was that the dimension in AutoCAD 2004 did not have the reactor (discussed below). Only when I created the dimension in AutoCAD 2010 was the reactor added.

Let’s learn this lesson with an example

Everybody knows that when you dimension an object, the dimension automatically updates when you modify the object. Have you ever wondered how the dimension knows it has to update? AutoLISP can help you find this out, if you don’t already  know.

Here’s the example:

1. Draw a line.

2. Get its entity list by typing the following piece of AutoLISP code at the command prompt:

(entget (car (entsel)))

and selecting the line when prompted to select an object. You’ll see something similar to the following at the command line in return.

((-1 . <Entity name: 7ee45a18>) (0 . “LINE”) (330 . <Entity name: 7ee43cf8>) (5 . “22B”) (100 . “AcDbEntity”) (67 . 0) (410 . “Model”) (8 . “0″) (100 . “AcDbLine”) (10 10.0 10.0 0.0) (11 160.0 160.0 0.0) (210 0.0 0.0 1.0))

This, you might have guessed, is the record that AutoCAD stores in its database.

3. Create a dimension (aligned for example) to show the length of the line and get the entity list of the line again. You should get a result similar to:

((-1 . <Entity name: 7ee45a18>) (0 . “LINE”) (5 . “22B”) (102 . “{ACAD_REACTORS”) (330 . <Entity name: 7ee45ae8>) (102 . “}”) (330 . <Entity name: 7ee43cf8>) (100 . “AcDbEntity”) (67 . 0) (410 . “Model”) (8 . “0″) (100 . “AcDbLine”) (10 10.0 10.0 0.0) (11 160.0 160.0 0.0) (210 0.0 0.0 1.0))

You might have noticed a new item starting with (102 . “{ACAD_REACTORS”) (330 . <Entity name: 7ee45ae8>) (102 . “}”) in the entity list of the line.

This is a reference to a reactor object that AutoCAD has created after adding the dimension. This reactor ensures that dimension gets modified when the object (line in this case) gets modified.

A reactor is a program that executes automatically when a particular action (change in the length of line in this case) is completed. A reactor executes only AFTER an editing action is completed. Hence, you see that the dimension is modified after the command that modifies the line completes and is not dynamically updated while length of line is being modified.

4. Next, entget the dimension using the same code but selecting the dimension this time.  You will get something similar to:

((-1 . <Entity name: 7ee45a20>) (0 . “DIMENSION”) (5 . “22C”) (102 . “{ACAD_XDICTIONARY”) (360 . <Entity name: 7ee45a90>) (102 . “}”) (102 . “{ACAD_REACTORS”) (330 . <Entity name: 7ee45ae8>) (102 . “}”) (330 . <Entity name: 7ee43cf8>) (100 . “AcDbEntity”) (67 . 0) (410 . “Model”) (8 . “0″) (100 . “AcDbDimension”) (280 . 0) (2 . “*D6″) (10 173.511 146.489 0.0) (11 98.5106 71.4894 0.0) (12 0.0 0.0 0.0) (70 . 33) (1 . “”) (71 . 5) (72 . 1) (41 . 1.0) (42 . 212.132) (73 . 0) (74 . 0) (75 . 0) (52 . 0.0) (53 . 0.0) (54 . 0.0) (51 . 0.0) (210 0.0 0.0 1.0) (3 . “Standard”) (100 . “AcDbAlignedDimension”) (13 10.0 10.0 0.0) (14 160.0 160.0 0.0) (15 0.0 0.0 0.0) (16 0.0 0.0 0.0) (40 . 0.0) (50 . 0.0))

You will notice that exactly same reactor appears in the entity list of dimension. Thus, this reactor is the link between the line and dimension.

5. Add one more dimension to the line and get the entity list of line once more. You will see one more item with (330 . in the reactor reference. Thus each dimension associated with line is added as an item with 330 dxf code in the entity list of line..

6. Now delete one of the dimensions and get the new entity list of the line. You will find that one of the (330 . item has been removed.

7. After you delete all dimensions, the entity list of the line returns to its original form without any (102 . items.

A possibility to improve associativity

It is interesting to note that when object is deleted, dimension does not get deleted. Thus it lacks true associativity with the object.

You could create a situation whereby the dimension would be deleted when the object was deleted by adding a reference to one more reactor in the dimension’s entity list that responds to deleting its associated object, but you would have to write code to do so.

Sanjay Kulkarni is an experienced CAD (AutoCAD, Inventor, SolidEdge, CATIA, NX) programmer and a member of the Autodesk Developer Network. He is fluent in AutoLISP, VBA, and VB.NET. He has written for AugiWORLD and Inside AutoCAD (a monthly magazine that has since gone out of publication). You can contact him at sanganakskha@gmail.com.

This post describes the method to load an AutoLISP program in an open drawing.

An AutoLISP program runs inside (in the same workspace of) an open drawing. Therefore it is necessary to load the program in [...]]]>

This is a guest post by Sanjay Kulkarni, an AutoCAD programmer.

This post describes the method to load an AutoLISP program in an open drawing.

Some basic & fundamental information before we move to the procedure

An AutoLISP program runs inside (in the same workspace of) an open drawing. Therefore it is necessary to load the program in each individual drawing you want to use the program in. You can load a program into a drawing at any time.

Once you load the program in a drawing, it remains loaded into that specific drawing until the drawing is closed. This means that you can use the functions in the program multiple times once you load the program.

The flip side is that you can’t unload an AutoLISP program once you load it except by closing the drawing.

If you want to use the same program in multiple drawings, you will need to load the program in each individual drawing even if there exists a drawing in which the program has been already loaded.

Loading an AutoLISP program

Now to the action:

1. Type appload at the command prompt (In AutoCAD 2012, you can go to Manage tab>Applications panel>Load Application.). This will display the Load/Unload Applications dialog box as shown below.

1. Click the History List tab at the bottom of the dialog box. In case the program was previously loaded in any drawing with Add to History checked, it will be listed there. Select the desired file in the list and go to step 7. Otherwise, go to step 3.
2. Make sure that Files of type displays the .lsp extension.
3. Using the LookIn drop-down, you browse to the desired location (folder).
4. If you want to be able to use step 2 above in future, select the Add to History checkbox.
5. Select the .lsp file to load in the window.
6. Click Load. If the file is successfully loaded, a message to that effect is displayed at the bottom of the dialog box. Also if you have checked Add to History, the names of loaded programs are added to in the History List tab of the window.
7. Click the Close button to close the dialog box.

You are now ready to use the functions in the loaded files.

Notes:

• You can select multiple files in the History List or the browser using Shift & Control keys and then click the Load button to load all the selected files simultaneously.
• You can double-click on an individual file to both select and load it. Then you don’t need to click the Load button.
• When you double-click on a file in History List with Add to History checked, the file name is added again to the History List. You can remove filenames in the History List by selecting the file and clicking the Remove button.
• If you load a file multiple times in a drawing, AutoCAD does not generate any error and overwrites the previous version of the loaded file.

For a quicker method of loading a program, see the tip, “Loading AutoLISP programs quickly.” This will also obviate the need to load program in each drawing.

Sanjay Kulkarni is an experienced CAD (AutoCAD, Inventor, SolidEdge, CATIA, NX) programmer and a member of the Autodesk Developer Network. He is fluent in AutoLISP, VBA, and VB.NET. He has written for AugiWORLD and Inside AutoCAD (a monthly magazine that has since gone out of publication). You can contact him at sanganakskha@gmail.com

In an earlier post, Ellen showed how to align a rectangle with a line on the fly. You can easily create the same effect using AutoLISP. This AutoLISP routine is simple, and you [...]]]>

This is a guest post by Sanjay Kulkarni, an AutoCAD programmer. You can read more about him at the end of this post.

In an earlier post, Ellen showed how to align a rectangle with a line on the fly. You can easily create the same effect using AutoLISP. This AutoLISP routine is simple, and you can use the code as a starting point for your own routines.

First, Ellen has created a video to show you how this works.

Here are the steps to use this AutoLISP routine:

1. Download the AutoLISP file. You need to do this only once, of course.
2. Start the APPLOAD command. In AutoCAD 2012, you can go to Manage tab>Applications panel>Load Application.
3. In the Load/Unload Application dialog box, make sure that the Files of Type drop-down list displays the .lsp extension. In the Look In box, navigate to the AutoLISP file and select it.
4. Click the Load button. You should see a message at the bottom of the dialog box saying that the file was successfully loaded.
5. Click Close to close the dialog box. For a quicker method of loading a program, see my tip, “Loading AutoLISP programs quickly“.
6. Draw a diagonal line in your drawing.
7. On the command line, type ra and press Enter.
8. Follow the prompts. At the Select the line to align rectangle with: prompt, select the line to align the rectangle with. The program repeats the prompt until you select a line or press the Escape key to abort the program.
9. At the Specify first corner point or [Chamfer/Elevation/Fillet/Thickness/Width]: prompt, specify the first corner of the rectangle. You can now see that the rectangle is aligned with the line.
10. At the Specify other corner point or [Area/Dimensions/Rotation]: prompt, specify the other corner of the rectangle to finish the routine and create a rectangle aligned with the selected line.
    

Tip: You can repeat the command in the drawing as long as the drawing is open. But if you open another drawing you will need to reload the program. To avoid having to do this, you can add it to your Startup Suite. In the Load/Unload Application dialog box, drag the AutoLISP file from the list of files at the top to the Startup Suite in the lower-right section of the dialog box.

I won’t show you the actual code in all my posts, but this one is simple enough that it will be useful to look at its structure. As I said, you can use this same structure for many situations. It’s similar to a script file; you are using the COMMAND function to execute an AutoCAD command. The code also defines an alias, RA. The PAUSE function waits for your input. Of course, the code also defines some variables, does some error checking, sets up the prompts, and a little more.

(defun RectAlin ()
(setq oOSMODE (getvar “osmode”))
(setvar “osmode” 0)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; selecting the line
(setq theLine nil)
(while (= theLine nil)
(setq theLine
(car
(entsel
“\nSelect the line to align rectangle with [Escape to cancel]:”
)
)
)
(setq eLstLine (entget theLine))
(if (/= (cdr (assoc 0 eLstLine)) “LINE”)
(setq theLine nil)
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(setq sPt (cdr (assoc 10 eLstLine)))
(setq ePt (cdr (assoc 11 eLstLine)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Create aligned rectangle
(command “rectang” PAUSE “R” “P” sPt ePt PAUSE)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(setvar “osmode” oOSMODE)
(princ)
)
(defun c:RA ()
(RectAlin)
)

Do you use AutoLISP in this way? Let us know how you use simple routines like this in your work–leave a comment!

Sanjay Kulkarni is an experienced CAD (AutoCAD, Inventor, SolidEdge, CATIA, NX) programmer and a member of the Autodesk Developer Network. He is fluent in AutoLISP, VBA, and VB.NET. He has written for AugiWORLD and Inside AutoCAD (a monthly magazine that has since gone out of publication). He can be contacted at sanganakskha@gmail.com

When I first started to drive a car, I had the feeling that I was not the one in control. [...]]]>

Note: This is an article by Fran Golding, Senior Drafter at Parsons Brinckerhoff, a large planning, environment and infrastructure firm with offices in Australia and New Zealand. Perhaps you can add your own productivity boost ideas.

When I first started to drive a car, I had the feeling that I was not the one in control. The car was controlling me. It took some

Out of control

time and practice before that changed. Likewise, when I started to use AutoCAD, I had the same feeling. All sorts of things happened which I did not understand. With time and practice (quite a lot of time and practice, I might add), that changed. As with driving a car, I did the same functions, the same way in which I was taught. It wasn’t until I had more confidence in what I was doing that I branched out and tried new ways of doing things. Thence came the beginning of my productivity boost!

Unlike driving a car, AutoCAD performs the same functions in many different ways. You can start the PLOT command by typing plot at the command line, choosing a toolbar or ribbon icon, or choosing File> Print from the drop-down menu (with variations depending on your release and workspace). Any of these will perform the same result. When you are first learning to “drive” AutoCAD, chances are you will generally follow the exact method which you were taught. It’s not until you understand how the program works that you can speed up what you do by creating shortcuts.

I am always surprised to find that users with many years experience still perform functions the long way. Often it depends on what (or who) they have been exposed to at their jobs. It rings true for any trade – if you have an innovative mentor, you will be more innovative! With the technological information super highway we have so much information at our finger tips. There is just no need to plod along doing the same things, the same way, year after year, after year!

“How much difference can it make?” I hear you asking. If we measure key strokes performed in a day, then reduce them by only one key stroke, it compounds to a staggering saving in a year.

To increase your productivity, you don’t need to reinvent the wheel. If you don’t know where to start and you don’t have a resident CAD guru in your office, don’t despair! An Internet search will return countless results. Don’t be put off. Start your journey with that one step. It will lead to the next in a very short time.

Create aliases

The very first step which I took was to add some command aliases to my ACAD.PGP file. Aliases allow you to type one letter at the command line instead of the full word, such as E for Erase, C for Copy or M for Move. They cut out many key strokes. Editors note: In AutoCAD 2010, go to Manage tab> Customization panel> Edit Aliases to customize acad.pgp. You can also open acad.pgp from Windows in a text editor; its location varies according to your release and Windows version.

Part of the acad.pgp file

Write simple AutoLISP routines

The next step which I took was to write some very simple AutoLISP routines. I began my own AutoLISP file which I added to the Startup Suite. This means you do not need to load the routines individually each time you start AutoCAD. Editors note: To add a .lsp file to the Startup Suite, use the APPLOAD command. In the Load/Unload Applications dialog box, locate the file and drag it to the Startup Suite icon.

Drag AutoLISP files to the Startup Suite

Some examples of these very simple routines are getting distance measurements with selected object snaps. For example, I sometimes need to obtain a distance nearest an object or line, then perpendicular to an object or line. The coding for this looks like: (defun C:DNP () (command “DIST” “NEA” pause “PER”))

Then, typing DNP at the command line allows me get the information I need. You might say that you can easily set OSNAPS and achieve the same thing, but the above coding ensures that the correct object snap is used every time. This can often be critical.

Editor’s note: The syntax is (defun C:[name] () (command “DIST” “[osnap]” pause “[osnap]“)) where [name] is the name of the custom command you are creating and what you type to execute it and [osnap] is any object snap you want to use. The pause command stops the execution of the routine for user input, in this case, specifying a point.

From here there are many more such command combinations that you can write using the same syntax, and substituting different object snaps, such as:

• DII (distance from intersection to intersection):
  (defun C:Dii () (command “DIST” “INTERSECTION” pause “INTERSECTION”))
• DEE (distance from endpoint to endpoint)
  (defun C:DEE () (command “DIST” “ENDPOINT” pause “ENDPOINT”))
• DEP (distance from endpoint to perpendicular)
  (defun C:DEP () (command “DIST” “ENDPOINT” pause “PERPENDICULAR”))

Likewise, you can write many AutoLISP routines to draw lines using selected object snaps:

• LINE command from Nearest, then Perpendicular to an object or line:
  (defun C:LNP () (command “LINE” “NEA” pause “PER”))
• LEE (line from endpoint to endpoint):
  (defun C:LEE () (command “LINE” “ENDPOINT” pause “ENDPOINT”))
• LME (line midpoint to endpoint):
  (defun C:LME () (command “LINE” “MIDPOINT” pause “ENDPOINT”))

Editor’s note: Here, the syntax is similar, but uses the LINE command instead of the DIST command.

Once you start writing these, you can easily add others. Even slightly more complex AutoLISP routines will become easy to write. For example, you can write AutoLISP routines to change system variables such as turning wipe out frames on or off.

• To turn wipe out frames on:
  (defun C:WF1 () (command “WIPEOUT” “FRAME” “ON”))
• To turn wipe out frames off:
  (defun C:WF01 () (command “WIPEOUT” “FRAME” “OFF”))

If you look closely at the coding, you will notice that the text inside the inverted commas [quotation marks] is what you would normally type at the command line.

Another series of handy AutoLISP routines is creating frequently used layers, setting their colour and setting them to current. For example, the company I work for specifies that all dimensions are drawn on a layer called “DIMS” which has the color 2 (yellow). The AutoLISP to create this layer looks like: (defun C:D2 () (command “-LAYER” “N” “DIMS” “S” “DIMS” “C” “2” “”))

You can then write extras to add many more layers such as a layer to draw hatches would look exactly the same as for DIMS with the appropriate substitutes. For example: (defun C:H2 () (command “-LAYER” “N” “HATCHES” “S” “DIMS” “C” “2” “”))

My company also has a dedicated layer for inserting external reference drawings called XREF. So, the code to create this and set it current looks like: (defun C:X2 () (command “-LAYER” “N” “XREF” “S” “DIMS” “C” “2” “”))

Here are some more of my favourites:

• To lock or unlock viewports:
  (defun C:V0 () (command  “MVIEW” “LOCK” “OFF” pause “”))
  (defun C:V1 () (command  “MVIEW” “LOCK” “ON” pause “”))
• To fillet lines using a zero radius:
  (defun C:F0 () (command  “FILLET” “R” “0”) (command “FILLET”))
• To fillet using a supplied radius:
  (defun C:FR () (setq rad (getstring “\n Enter Radius:”))
  (command  “FILLET” “R” rad)
  (command “FILLET” pause pause)
  (princ))

Editor’s note: This last routine uses the setq AutoLISP command to set a variable named rad to the result of user input in response to the Enter Radius: prompt. It then uses the result to set the fillet radius.

The key to successfully boosting your productivity is to keep on learning. You will be surprised how much greater satisfaction you will get out of increasing your learning. Greater productivity leads to a win-win situation. Your employer will be pleased, and who knows — that may lead to greater remuneration. In this article, I want to encourage all users to embrace the latest and strive to be more productive each day!

Answer: An easy way is to type the AutoLISP routines in a file and save it as anything.lsp. Then choose Tools> AutoLISP> Load Application. Browse to anything.lsp and drag it [...]]]>

Question: B.N. asks how he can get his AutoLISP routines from an earlier release into AutoCAD 2007 so that they’re always loaded and ready to go.

Answer: An easy way is to type the AutoLISP routines in a file and save it as anything.lsp. Then choose Tools> AutoLISP> Load Application. Browse to anything.lsp and drag it to the Startup Suite, which has an icon of a suitcase. Then it will load whenever you start AutoCAD.

Febien Mosen sent me another routine, SCISSORS, that has 3 features:

Command: cursorsize Enter new value for CURSORSIZE <5>: 100

You can also choose Tools>Options and click the Display tab. There you can type in [...]]]>

AutoCAD 2000 sets the default for the cursor at 5% of the screen. Many people like the old full-screen cursor. Abdul Nazar emails from India that you can change the cursor using this prompt.

Command: cursorsize
Enter new value for CURSORSIZE <5>: 100

You can also choose Tools>Options and click the Display tab. There you can type in a new cursor size or use the slider bar.

Bob Abernethy contributed a short AutoLISP file that toggles the cursor size from 5% to 100% and back again. He includes a bitmap file that you can use for a toolbar button. Download it.