Speaker Name: Bill Kramer. Course: CP31-2 A Visual LISP Wizard's Advanced Techniques. Course Description

Transcription

1 Speaker Name: Bill Kramer Course: CP31-2 A Visual LISP Wizard's Advanced Techniques Course Description Ready to move beyond DEFUN, SETQ, GETPOINT, and COMMAND? This class is intended for veteran AutoCAD LISP programmers who already know the basics of creating LISP applications and are ready to learn some new tricks. Objects, Active X servers, reactors, lists, recursion, and dynamic dialogs are just some of the advanced techniques. Each topic will include an example scroll (program that we'll explore in detail as we learn the concepts involved and become more familiar with the features available to the Visual LISP programming wizard.

2 Α ςισυαλ ΛΙΣΠ Ωιζαρδ σ Αδϖανχεδ Τεχηνιθυεσ Bill Kramer Advanced Techniques This is NOT an introduction to Visual LISP class! I am going to assume you know things like SETQ and DEFUN, the difference between an integer and a real, the difference between entity lists and names, and the basics of the Visual LISP language. Using examples, we will learn about a variety of Visual LISP elements including: Objects, ActiveX Servers, Reactors, Lists & recursion, Dialog boxes, and more. We will not go into great detail for everything - we don't have enough time for that. But the goal is to introduce these aspects of Visual LISP with an example so that you can see they exist and begin to learn how to exploit them. The Challenge presented by a class of this nature is rather extreme for the instructor. The challenge is to create a set of examples that transcended all disciplines. That is, create something that is equally useless to everyone but yet shows a lot of the Visual LISP language. So instead of a bunch of disassociated examples I thought how about a complete, but useless, application? And since we are in Vegas, I decided how about "AutoKeno"? The Example Application will run a KENO type game in AutoCAD. It uses objects, can keep track of data in lists and objects, can be enhanced with reactors - basically it will show many different advanced techniques and be fun as well! AUTO-KENO Specifics The basic program outline is simple: Draw a Keno card (we ll use 100 numbers Allow the user to select a set of numbers Generate a list of 20 random numbers (1-100 Compare lists to compute winnings Draw a Keno Card The goal is to place 100 numbers in the drawing in ten rows of ten columns. A nested or double loop can be used to accomplish this action. (repeat 10 (setq P1 (list (car BaseP (- (cadr P1 RD 0.0 (repeat 10 (Text_At P1 (itoa N (setq N (1+ N P1 (polar P1 0.0 CD

3 Function (TEXT_AT will draw the text Variables needed BEFORE starting loop BaseP = Base point of chart P1 = initially set to BaseP CD = distance between columns RD = distance between rows N = initially set to 1 Coding (TEXT_AT What is the simplest format for creating this function. The options are to use the (COMMAND expression, we could also use the ENTMAKE form, or we can use the Object form. The real question is "Will we want to do anything else with it?". If we think we might, then it is important to know that the object form enables the easiest expansion. Drawing with Objects The term Drawing should actually be Adding. The reason is that objects are added to the drawing. The programmer decides where to add them. The options are to add them to a named block or to model space or to a named paper space. In each case you simply establish an object link with the host and then add the new object to it. In AutoCAD, everything is in the block table. Model and paper spaces are block references in this same table. To get to the model space object start at the root, the AutoCAD object. (setq ModelSpace (vla-get-modelspace (vla-get-activedocument (vlax-get-acad-object Given link to the space or block where you want to add a new object, use Add... as in (VLA-AddText ModelSpace... We will now look into the remaining parameters of the VLA-ADDTEXT function. You will not find (VLA-AddText in the help system for Visual LISP directly. You need to use the VBA help to locate "ADDTEXT". (VLA-AddText <space> <string> <point> <hgt>

4 Utility Function (LinkModelSpace (defun LinkModelSpace ( (if (null ModelSpace (setq AcadObj (vlax-get-acad-object ActiveDoc (vla-get-activedocument AcadObj ModelSpace (vla-get-modelspace ActiveDoc ModelSpace The (TEXT_AT Function (defun Text_At (P1 TX (vla-addtext (LinkModelSpace TX (vlax-3d-point P1 (getvar "TEXTSIZE" Function VLAX-3D-POINT converts a point list into a variant array for use in the object system. Object Approach Simple and sweet, although a bit rough to read when first learning and getting used to VBA help conversions. The biggest feature of the object approach is future expansion. Object based systems can often be expanded with ease. When used in Visual LISP you simply save the Object reference returned from the ADD function. Then use the reference with a large host of other functions to accomplish a variety of activities. Back to the Keno application (repeat 10 (setq P1 (list (car BaseP (- (cadr P1 RD 0.0 (repeat 10 (text_at P1 (itoa N (setq N (1+ N P1 (polar P1 0.0 CD Set up the Variables (defun Make_Keno_Card ( (initialize_keno_variables (repeat 10...

5 Initialize the Variables CD = 0.9 Column distance RD = 0.75 Row distance BaseP = '( Base point P1 = BaseP Setting up the drawing This application has complete control of the environment, a luxury! Before creating a new card we will want to make room for it and now is when we must consider the standards by which the card will be drawn. The following rules will be used in this application: Text to layer 0 using TextSize variable When selected, text objects will move to layer PICK When Keno ball played, text object will move to layer USED or layer WIN Layers use colors to allow us to see what is going on. Layer and color assignments 0 = White/black PICK = Cyan blue USED = Red WIN = Green The Command Approach (defun Setup_Keno_Layers ( (if (null (tblsearch "LAYER" "Used" (command "_LAYER" "_N" "Used, Win, Pick" "_C" "Red" "Used" "_C" "Green" "Win" "_C" "Cyan" "Pick" "" The Object Approach (defun Setup_Keno_Layers ( / LL LayerTableObj (setq LayerTableObj (vla-get-layers (vla-get-activedocument (vlax-get-acad-object (setq LL (vla-add LayerTableObj "Used" (vla-put-color LL acred (setq LL (vla-add LayerTableObj "Win" (vla-put-color LL acgreen (setq LL (vla-add LayerTableObj "Pick" (vla-put-color LL accyan Object work is more coding however greater control is available at the time the operation is taking place thus allowing future revisions to take advantage of the already coded object references. Finish the set up process

6 (text_at (list (car BaseP (- (cadr P1 (* 0.8 RD 0.0 "Visual LISP AutoKENO - AU 2003" Display available funds for operator (text_at (list (car BaseP (+ (cadr BaseP (* 2.0 RD 0.0 (strcat "Available funds = " (itoa AvailableFunds Save link to available funds string (setq AvlMsg (vlax-ename->vla-object (entlast Spruce up the place, a casino should look neat. (command "_RECTANG" '(0 0 0 (mapcar '+ P1 (list CD (- RD 0.0 "_ZOOM" "_E" "_ZOOM" "0.8x" Put all the above together into a function set to create the card and draw the text labels with the screen centered. This completes the setup of the Keno card. The next step involves the most "danger", the user input. User Selection The next step involves the operator selecting the numbers to play on the card. Now we should really let the operator select the numbers using the object pick box instead of making them type in numbers. The reason we chose to note that a number was picked using a layer system makes this sort of user interface quite easy. But anytime the user input is involved we need to be careful. We need to make sure we do the right thing, react the right way, and are ready for anything that is unexpected. This is another reason to make user selection graphical instead of based on the keyboard. The simpler the better as there are fewer places where an error might occur. A single pick of the number in the drawing will be much easier than typing in the value. Let's define the house rules for AutoKENO. The operator will select a series of up to ten numbers. Each number costs one unit (we will start with fifty to play. As the operator selects the numbers the layer will change from "0" to "PICK". The selection results in the number being picked and one unit being subtracted from the available play units. If selected a second time the number text will go from layer "PICK" back to "0". At the same time a credit of one unit will be applied.

7 Start by pseudo coding the module we want to program. Pseudo code is like real code, but a lot more readable. (TIP: It can be done in the VLIDE as comments in a new function. if no units, make it four selection count = 10 if available funds < 10 then Selection count = available units Loop until selection count reached or operator is done making selections In the loop we want the operator to select an object. Of course, we will need to make sure the object selected is valid! If it is then we will change the layer. Check selection is Text and the right kind of text (number Checks okay, next look at the layer If Layer "0" then change to Layer "Pick" subtract one from selection count else If Layer "Pick" then change to Layer "0" add one back to selection count end both ifs Operator Selection and Testing -> Select From Card (defun Select_From_Card ( / CNT EN EL CNTBASIS LYR (setq CNT 10 (if (> CNT AvailableFunds (setq CNT AvailableFunds (setq CNTBASIS CNT (while (> CNT 0 (setq EN (car (entsel "\npick up to 10 numbers: " (if EN (progn (setq EL (entget EN (cond ((/= (cdr (assoc 0 EL "TEXT" (prompt " Please select a TEXT object." ((zerop (atoi (cdr (assoc 1 EL (prompt " Please select a proper TEXT object." ((/= (setq LYR (strcase (cdr (assoc 8 EL "0" (prompt " Object not on layer 0" (if (= LYR "PICK" previously selected! (progn (setq CNT (1+ CNT AvailableFunds (1+ AvailableFunds (prompt " - deselected." (entmod (subst (cons 8 "0"

8 (assoc 8 EL EL (T (prompt " Registering selection." (setq CNT (1- CNT AvailableFunds (1- AvailableFunds (entmod (subst '(8. "PICK" (assoc 8 EL EL end T end COND end PROGN (setq CNT (- CNT nothing or enter - exit the function. end IF (+ CNTBASIS CNT AUTO-KENO We now have completed drawing the card by adding objects to a clean drawing and then allowing the operator to make selections on the card. Next consideration involves randomly selecting 20 numbers as the Keno play. Amongst the things to think about are the display of selections, keeping track of the selections, and the more critical question of how to produce a random number. How to get a random number? Visual LISP does not provide a random number generator. I know when I first heard of a random number generator, I thought it was pretty silly. I mean, why generate a random number? When my equations were incorrect I got plenty! It was not until later in my computer programming education that I came to learn about creating simulations using random numbers. One can create a model of something and then feed it random numbers with constraints to see how it reacts. Given enough iteration the results can be amazingly accurate in modeling complex reality situations. Another place where random numbers are quite useful is games. But our question is "Can we create a random number generator?" The answer is yes, by using the system date and then pausing long enough for the seconds to change enough to grab the sub-second value. Repeat 1000 times to allow enough time to pass. (defun RANDOM ( / CE (repeat 1000 (setq CE (getvar "CDATE" YYYYMMDD.HHMMSSss CE (- CE (fix CE CE (* CE CE (- CE (fix CE CE (fix (rem (* CE There is a "Better" way Although VL has no random number, VBA does! The RND function in VBA creates a

9 random number given a seed number to get it started. So now the question is how to connect to VBA from VL. Related to that question is how to move data between the two environments. The easiest method of sending data between VL and VBA is to use system variables. Each system variable is supposed to house temporary data for applications to use. There are five each for integers, real numbers, and strings. UserI1 through UserI5 UserR1 through UserR5 UserS1 through UserS5 Loading VBA projects using VL is accomplished using (VL-VBALOAD. Provide the file name of the VBA project (DVB extension and Visual LISP will load the VBA project into memory. It is assumed you know what you are doing with the VBA project of course. Once a VBA project is loaded you call up the Macros by name using (VL-VBARUN. The name of the macro is supplied as the sole parameter. Nothing is returned immediately from (VL-VBARUN that you can use. And it is important to realize that when you start running a VBA macro it will run SIMULTANEOUSLY with your Visual LISP macro. As a result there is a chance you will be looking into the system variables BEFORE the VBA macro has completed the task. The speed of the application is what controls the way you need to handle this situation. You could go into a waiting loop of some sort. But we just need to create a RANDOM number macro in VBA. That is a fairly fast computation. A VBA Booster VBA Source Code The project source code for generating a random number and placing it in the USERI1 system variable is presented at left. If you do not "speak" VBA do not panic, it is pretty simple stuff. The macro we will be calling is RandomVLCall. It uses the RND( internal function after setting a new seed. The random number is multiplied by 100 and then rounded off to an integer with FIX. This will return a value between 0 and 99. The value of NUMB (a function is sent to the "UserI1" system variable in AutoCAD using SetVariable. Now let's look at the Visual LISP side! Function Random (defun Random ( (if (null Random_VBALoaded

10 (vl-vbaload "/my documents/au2003/random.dvb" (setq Random_VBALoaded T (vl-vbarun "RandomVLCall" (getvar "UserI1" Using VBA with Visual LISP You can utilize the improved Dialog Box system of VBA or interface with other ActiveX based applications using VBA if you know the language. Sometimes a blending of Visual LISP and VBA can create a wonderful thing! It is also possible to utilize a DLL created in VB, C++, Delphi, or whatever can create a Microsoft object program. Using (VL-IMPORT-TYPE-LIBRARY you can import an entire ActiveX library into your Visual LISP application opening the door to some wonderful applications such as talking to Excel or Access or Word... Returning to the application We have solved the problem of generating a random number, now we need to return to the running of a card. To run a card we select 20 random numbers where each is unique (cannot repeat. After selecting the number with the random number generator we will mark the display using the following logic. If match, change to layer WIN If no match, change to layer USED Unique random number set To make sure we have unique random numbers we will keep a list of used numbers. If the number selected is a member in the list, then the number has already been used. A simple WHILE loop can be employed to keep checking for random numbers. (setq RR (1+ Random (while (member RR Used (setq RR (1+ (Random Pick a number Given just the random number, how to find the text entity? Since the text entity was generated programmatically we can always locate it programmatically. That is a luxury of having complete control over the drawing environment. Otherwise we may have built a list of numbers with the object reference for quick look up. (defun Where_On_Card (Num (setq Row (1+ (fix (/ (1- Num 10 Col (1- (rem Num 10 (if (minusp Col (setq Col 9 (list (+ (car BaseP (* Col CD (- (cadr BaseP (* Row RD

11 0.0 Playing the card The (Where_On_Card function returns a point based on a calculation. The problem is simply that a TEXT object will not always be at that exact location. Text objects in AutoCAD are based on font definitions and the exact location of the character elements may not be the location where the text was placed. Consider the letter "O". The bottom corner is where the text is placed but there are no pixels illuminated at that location. To locate the text object we will use (NENTSELP to select the object. (NENTSELP uses the pick box size (measured in pixels and searches that area for potential selections. In our program we will check the calculated location and then increase the search box if nothing is found. (setq Saved_PB (getvar "PICKBOX" (setq EN (nentselp PT (while (null EN (setvar "PICKBOX" (1+ (getvar "PICKBOX" (setq EN (nentselp PT Update the display Given the text object we can substitute the text size and layer in the entity list and then update the display using ENTMOD. (setq EL (entget (car EN (if (= (cdr (assoc 0 EL "TEXT" (progn (setq EL (subst (cons 40 (* 1.5 (cdr (assoc 40 EL (assoc 40 EL EL EL (subst (cons 8 (if (= (cdr (assoc 8 EL "0" "USED" "WIN" (assoc 8 EL EL (entmod EL Or using Object References (setq EN (vlax-ename->vla-object (car EN (if (= "AcDbText" (vla-get-objectname EN (progn (vla-put-height EN (* 1.5 (vla-get-height EN (vla-put-layer EN (if (= (strcat (vla-get-layer EN "0" "USED" "WIN"

12 Report the Results (defun Report_Keno_Results ( (setq SS1 (ssget "X" '((0. "TEXT"(8. "WIN" (alert (if SS1 (progn (setq AvailableFunds (+ AvailableFunds (nth (1- (sslength SS1 PayOff (vlax-put-property AvlMsg 'TextString (strcat "\nfunds remaining = " (itoa AvailableFunds (command "_REDRAW" (strcat "\nyou picked " (itoa (sslength SS1 " correctly adding " (itoa (nth (1- (sslength SS1 PayOff " to your available funds!" "\nno correct picks, sorry." The "Pay off" The pay off values are saved as a list. The Nth position corresponds to number correctly guessed minus one. (setq PayOff '( If the number correct is two (2, then subtract one and use NTH. The result would be a pay off of five (5. Our simple Version is Cool! And we can make it cooler! A program is NEVER finished. How about circling the selections when they are made by the operator? How about changing the available funds as they are selected? We want to add more when things change. Adding New Features There are two places to add new features based on changes. We can add them back where the original was created or modified. Or by using reactors. Reactors work well with changes in the drawing! So that is where we will focus our attention. Adding Reactors To add a reactor, we only need to first program the reactor actions and then set up the reactor linkage as the objects are created as the program runs.

13 There are several types of reactors in Visual LISP. We will only consider the two that relate to changes in the drawing database. Database Level reactors vlr-acdb-reactor ANY entity changes Object Level reactors vlr-object-reactor Specific entity changes Adding an Object Level reactor Vlr-object-reactor :vlr-modified :vlr-erased :vlr-copied... Others Change (Text_AT function by adding an object level reactor. (defun Text_AT (P1 TX / TxObj (setq TxObj (vla-addtext (LinkModelSpace TX (vlax-3d-point P1 (getvar "TEXTSIZE" (if Enable_reactor Add object level reactor (vlr-object-reactor (list TxObj nil '((:vlr-modified. KenoNumChange When adding a reactor Only add it once! You can add multiple reactors to an object and this can result in extreme confusion. Can link multiple objects to a single reactor. This is a way of grouping entities in AutoCAD beyond blocks and groups. Can link multiple events to objects. If you really need to keep track of what is going on with an object or group of objects you can. Need to write a function that handles the event call back. There will be two parameters to the function for the majority of reactor types. Object reactors have three parameters. The parameters will be the object reference of the linked object causing the callback, the object reference of the reactor, and in the case of the object reactors a list of parameters that will vary based on the event.

14 Adding a reactor Name of the function is provided in list to the VLR-xxx-REACTOR. You control the function name when you create the program source code. Now let us consider the nuances of programming an event callback function. Reactors need to be: Quick Clean Non-intrusive Programming or an Event Always check you have what you want. An event routine can be linked to multiple objects. If you simply verify that the object causing the event is the one you want to react to then you can save some headaches. Additionally you might want to employ flags to help let the event callback know when to do things and more important, when not to do things. The sequence of events is out of your control except when a BEGIN and END event series exist for a particular reactor. But you cannot anticipate when an exact event will take place. What this means is don't try to toss data between event functions expecting things to take place in a particular order. Beware of causing another event through the actions of your callback function. When working with entity object events you can modify other objects resulting in the callback function being called again (assuming that the entity object being modified is related to the original entity object by a reactor. Scanning for specific entities at the start of a callback can save extra processing time as the function returns quickest. Event termination is out of your control meaning that an event must finish on its own accord. There are times when you might want to stop an event such as the deletion of a critical entity object or an entity being moved to a location it should not be placed. Unfortunately your application will simply have to set some sort of flag indicating that clean up is needed at a later time or some related activity. Programming for an Event Careful planning will yield good results. This is common sense in most programming applications. You should think about when things will happen and try to anticipate in advance every possible reason your callback function will be invoked. Reactor programs need to be quick, clean, and efficient! Our Application Event When the Layer of a text object changes we want the function to react We have attached an object reactor named KenoNumChange to each text object in (TEXT_AT.

15 Pseudo coding of the reactor: Check if calling object is Text Get the layer name If the layer is PICK then The operator selected this object Get center point of the text Draw a circle about that point Somehow relate the text and the circle objects Relating the Text with the Circle As the new circle is added, we want to relate it to the text that was selected. It would be nice to build a link between the two at the entity object level however we cannot change the text object itself as it is the reacting object. Instead we need to establish a link between the two using another tool for customization: a dictionary. Dictionary A dictionary is a collection of non-graphic data in a drawing. Dictionaries are named by the application, which then uses keys to access data stored in the dictionary. (VLAX-LDATA-PUT Name Key Data (VLAX-LDATA-GET Name Key The Name is the name of the dictionary and can be anything you want. If a dictionary does not exist with the name provided and you are putting data in it, a new dictionary is created. The Key is a unique string that can be used to locate the data string. The GET function returns the "Data" string while the PUT function is used to place it in the dictionary. Create the circle entity (in this case we used ENTMAKE, VLA-ADDCIRCLE would work just as well. Get the Entity handle for the newly created circle. We used an entity list here. HDNL1 is set to the text entity object handle. (entmake (list '(0. "CIRCLE" '(8. "PICK" (cons 10 P1 (cons 40 RD (setq EN (entlast EL (entget EN (vlax-ldata-put "LINKS" HNDL1 (cdr (assoc 5 EL Store the data in the dictionary named "LINKS" using the handle of the text object as the key and the handle of the circle object as the data. This creates a linkage table so that when we know the handle of the text object we can get the related circle object. Finding the Center of the Text

16 (setq EN (vlax-vla-object->ename oobj EL (entget EN HNDL1 (cdr (assoc 5 EL TX (textbox EL P1 (mapcar '(lambda (p1 p2 p3 (+ p3 (/ (+ p1 p2 2.0 (car TX (cadr TX (cdr (assoc 10 EL RD (* 2.0 (getvar "TEXTSIZE" Get the entity data list and store it in EL. (Note the handle is retrieved into HNDL1 for later use as the text and circle are related as just described. The function (TextBox returns a list of two points given an entity list of a text object. These points are the top right and lower left limits of the text object. Average of text box limits added to base point of the text is the center. Since these are points, the best way to manipulate them is using a favorite of mine, MAPCAR. MAPCAR The power tool of list processing. For me it stands for Multiple Applications of CAR. Can be used to dig through a list or series of lists computing solutions for each list member and then returning a list as a result. Very handy for point manipulations! (mapcar + P1 P2 adds P1 and P2 points When more than just a simple function is to be evaluated, the LAMBDA expression can be used. Lambda is a temporary function and has a parameter list (like in DEFUN where each list member will be placed as the MAPCAR goes through the list. Back to the design Let's consider what we want our reactor to do. By looking at the layer we will do something. Layer PICK results in a new circle around the text Layer 0 removes the circle and link Layer WIN changes the layer of the circle too. We will update the available funds display at the same time. Layer "PICK" Reaction ((= LYR "PICK" Update funds (vlax-put-property AvlMsg 'textstring (strcat "Available funds = " (itoa AvailableFunds (setq EN (vlax-vla-object->ename oobj EL (entget EN

17 HNDL1 (cdr (assoc 5 EL Compute center TX (textbox EL P1 (mapcar '(lambda (p1 p2 p3 (+ p3 (/ (+ p1 p2 2.0 (car TX (cadr TX (cdr (assoc 10 EL RD (* 2.0 (getvar "TEXTSIZE" Add circle (entmake (list '(0. "CIRCLE" '(8. "PICK" (cons 10 P1 (cons 40 RD (setq EN (entlast EL (entget EN Add link entry (vlax-ldata-put "LINKS" HNDL1 (cdr (assoc 5 EL Layer "0" Reaction ((= LYR "0" Funds update (vlax-put-property AvlMsg 'Textstring (strcat "Available funds = " (itoa AvailableFunds Get the text handle (setq HNDL1 (vlax-get-property oobj "Handle" Get the circle link CirObj (vlax-ldata-get "LINKS" HNDL1 Kill the link entry in the dictionary (vlax-ldata-delete "LINKS" HNDL1 Erase the circle (entdel (handent CirObj Layer "WIN" Reaction ((= LYR "WIN" Get handle of text (setq HNDL1 (vlax-get-property oobj "Handle" Get link to circle CirObj (vlax-ldata-get "LINKS" HNDL1 CirObj (vlax-ename->vla-object (handent CirObj Update circle (vlax-put-property CirObj 'LAYER "WIN"

18 (vlax-put-property CirObj 'RADIUS (* 1.5 (vlax-get-property CirObj 'RADIUS Objects can be extended Reactors allow objects to be extended. Imagine if our application had many different places where the text was changed, we would have to change EACH and EVERY instance to update a feature as we have just done. Reactors are tools for making objects more powerful and extending their capacity. A Change of Example Let's move into our next example. In this case I selected something you can USE! The AutoKENO was fun and demonstrated many features of Visual LISP however it is not something that will help you next week when you are back at work. Our next example application utility does give you something you will find useful right away. Dynamic Dialog Boxes The idea is to create a dialog box on the fly each time program runs. Removes the need to keep DCL files around or keep track of them. This utility is handy for rudimentary dialogs and apps, and it can be used to prototype DCL files. And this example shows great list stuff! List Driven Dialog Box A list is used to supply the essential data to the dialog box generator. Each list member contains data about one of the tiles in the dialog box. Prompt or Label string Unique string used as Key Default value, a string or flag Strings for radio button options, each must be unique and will be used as a "Key". The utility function returns an association list. The prompt string is removed from each entry and the unique key string is used to access the data that follows in your program. List format: (( "Prompt" <"Key"> <"Default"> [<Toggle flag> <"Radio button" >...]... Dynamic Dialog Boxes

19 C_LIST is the important item Check for default settings where radio button rows are being used. Determine number of columns Get a folder name to stash the DCL file. TEST dialog box (setq data (dd "A program generated dialog box" '(("Field one" "F1" "1.23" ("Field two" "F2" "ABC" ("Field three" "F3" "1a2b" T ("Field four" "F4" "Choice 1" "Choice 2" "Choice 3" ("Text only Field Five" The Visual LISP code (defun DD (DPRMPT ;dialog box prompt C_LIST ;control list / TmpDir ;location of DCL file TMP ;input and output string KEY ;key name TAG ;tag value ITEM ;item in a loop RBUT ;radio button variable Tgls ;toggles CNT ;integer counter DIV ;divide up dialog into this many columns FH ;File handle (DD_SetUp (DD_Generate (setq C_LIST (DD_PrepRun (DD_RunDialog Set up the Variables used by the Dynamic Dialog Box generator Determine number of columns. DIV will be greater than the length of C_LIST for a single column. Otherwise it will half of the number of items in the list for two columns. This only comes into play if the number of elements in C_LIST exceeds 11. For radio rows, the default value is optional and assumed to be the first member of the radio group. This mapcar will look for situations where the default was not provided and add it to the individual sub-list member. (defun DD_SetUp ( (setq TmpDir (getvar "DWGPREFIX"

20 CNT 1 DIV (if (> (length C_LIST 11 (fix (/ (1+ (length C_LIST 2 (+ 2 (length C_LIST C_LIST (mapcar '(Lambda (Item if the following are all true (if (and (> (length ITEM 3 radio row? (= (type (cadddr ITEM 'STR (not NOT (apply 'OR any of the follow true? (mapcar third element equal radio option? '(lambda (T2 (= (caddr ITEM T2 (cdddr ITEM (append add default to start of list (list (car ITEM (cadr ITEM (caddr ITEM (cddr ITEM end append ITEM else just return item if not radio row end lambda C_LIST end mapcar and setq DD_Generate - Create the DCL file given the control list C_LIST containing prompts, tag or key names, and additional data for various tile types. Tile Types Sub-list format edit_box ("prompt" "tag" "default" text ("prompt" toggle ("prompt" "tag" <T or nil> radio_row of radio_buttons ("prompt" "tag" "default" "button1" "button2"... toggle and edit_box row ("prompt" "tag" "default" <T or nil> (defun DD_Generate ( Begin the dialog box definition (setq FH (open (strcat TmpDir "TEMP.DCL" "w" create temp DCL (write-line "DD : dialog {" FH (write-line (strcat "label = \42" DPRMPT "\42;" FH (if (< DIV (length C_LIST (progn (write-line ": row {" FH (write-line ": column {" FH (write-line "alignment = left;" FH (foreach ITEM C_LIST Is this a multiple column dialog box? (if (= (rem CNT DIV 0 (progn (write-line "}" FH (write-line ": column {" FH

21 (write-line "alignment = right;" FH (setq CNT (1+ CNT Limit prompt string to 30 characters fill in with dots. (if (> (length ITEM 1 (progn (setq TMP (substr (car ITEM 1 30 (while (< (strlen TMP 30 (setq TMP (strcat TMP "." Details for each tile based on length of ITEM (cond ((= (length ITEM 1 text box only (write-line ": text{value=" FH (write-line (strcat "\42" (car ITEM "\42;width=60;}" FH ((and (= (length ITEM 3 edit_box construction (= (type (caddr Item 'STR (write-line ": edit_box {" FH (write-line "edit_width = 12;" FH (write-line (strcat "label = \42" TMP "\42;" FH (write-line (strcat "key = \42" (cadr ITEM "\42;" FH (write-line "}" FH ((= (length Item 3 toggle box (write-line ": toggle {" FH (write-line (strcat "label=\42" TMP "\42;" FH (write-line (strcat "key=\42" (cadr Item "\42;" FH (write-line "}" FH (setq Tgls (cons (list (cadr Item (caddr Item Tgls ((/= (type (cadddr ITEM 'STR toggle/edit_box combo (write-line ": boxed_row {" FH (write-line ": toggle {" FH (write-line (strcat "label=\42" TMP "\42;" FH (write-line (strcat "key=\42tgl-" (cadr ITEM "\42;}" FH (write-line ": edit_box {" FH (write-line "edit_width = 12;" FH (write-line (strcat "key = \42" (cadr ITEM "\42;}" FH (write-line "}" FH ('t else it is radio row (write-line ": radio_row {" FH (write-line (strcat "label = \42" TMP "\42;" FH (setq TMP (caddr ITEM ;get default (foreach RBUT (cdddr ITEM

22 (write-line ": radio_button {" FH (write-line (strcat "key=\42" RBUT "\42;" FH (write-line (strcat "label=\42" RBUT "\42;" FH (write-line "}" FH (write-line "}" FH (if (< DIV (length C_LIST (progn (write-line "}" FH (write-line "}" FH (write-line "ok_cancel;" FH (write-line "}" FH (setq FH (close FH Prepare control data list for run of the dialog box by removing prompts and text only entries. Returns the modified control list (defun DD_PrepRun ( / TMP ITEM (foreach ITEM C_LIST (if (> (length ITEM 1 (setq TMP (cons (cdr ITEM TMP (reverse TMP Run the dialog box created earlier. (defun DD_RunDialog ( (setq FH (load_dialog (strcat TmpDir "TEMP.DCL" (if (new_dialog "DD" FH (progn (foreach ITEM C_LIST (cond ((and (= (length ITEM 2 (= (type (cadr Item 'STR edit_box (action_tile (car ITEM "(DD_1 $key $value" (set_tile (car ITEM (cadr ITEM ((= (length Item 2 toggle box (action_tile (car ITEM "(DD_1a $key $value" (set_tile (car ITEM (if (cadr Item "1" "0" ((/= (type (caddr Item 'STR toggle/edit box combo (action_tile (car ITEM "(DD_1 $key $value" (set_tile (car ITEM (cadr ITEM (if (caddr Item (progn (set_tile (strcat "TGL-" (car Item "1"

23 (mode_tile (car Item 0 (progn (set_tile (strcat "TGL-" (car Item "0" (mode_tile (car Item 1 (action_tile (strcat "TGL-" (car Item "(DD_2 $key $value" (t radio row (foreach RBUT (cddr ITEM (action_tile RBUT (strcat "(DD_1 \"" (car ITEM "\" $key" (set_tile (cadr ITEM "1" (setq TMP nil trim out radio button options, add toggle options. (foreach ITEM C_LIST (if (and (> (length Item 2 (/= (type (caddr Item 'STR (setq TMP (cons (list (strcat "TGL-" (car ITEM (if (caddr Item "1" "0" TMP (setq TMP (cons (list (car ITEM (cadr ITEM TMP (setq C_LIST (reverse TMP (if (= (start_dialog 1 C_LIST return C_LIST contents Generic call back functions (DD_1 key value - edit box and radio button handling (DD_1a key value - toggle box (DD_2 key value - toggle with edit box handling Substitute data in C_LIST for the key. KY is the value that will be found in C_LIST. For edit boxes the KY value is the key/tag name. For radio buttons the value of KY is the radio group key name and VAL is the key name of the button selected. (defun DD_1 (KY VAL (setq C_LIST (subst (list KY VAL (assoc KY C_LIST C_LIST Substitute data in C_LIST for the key KY. This version is for toggles. If the VAL value is "1" then T is used, nil otherwise.

24 (defun DD_1a (KY VAL (setq C_LIST (subst (list KY (if (= VAL "1" 'T nil (assoc KY C_LIST C_LIST Substitute data in C_LIST for the key KY (toggle control and turns the tile for the associated text on and off. (defun DD_2 (KY VAL handle toggles (if (= VAL "1" toggle on (mode_tile (substr KY 5 0 turn it on (mode_tile (substr KY 5 1 off (DD_1 KY VAL Another Example Function The following code is another DCL file generator for list boxes. Just supply a list and a title and this function will return the operator's selection from the list. (defun DD_LGET ( Lname input data list Title string title of dialog Many multiple select flag / DCL_ID dialog handle NumbSel Numbers Selected FH File Handle RET Returning data list Cnt Counter (setq DCL_ID (make_list_dialog 60 Title Many (if (and DCL_ID (new_dialog "DLIST" DCL_ID (progn (setq NumbSel "" (start_list "LIST" (mapcar 'add_list Lname (end_list (action_tile "LIST" "(setq NumbSel $value" (start_dialog (if (/= NumbSel "" (progn (setq NumbSel (read (strcat "(" NumbSel "" CN 0 (while (< (length RET (length NumbSel (if (member CN NumbSel (setq RET (cons (nth CN Lname RET

25 (setq CN (1+ CN (setq RET (reverse RET (if DCL_ID (unload_dialog DCL_ID (if Many RET (car RET (defun MAKE_LIST_DIALOG ( Wdt text field Width Title dialog box title text Multi 'T if multiple select / FH File handle TmpDir Temporary directory Open the file TEMP.DCL in write mode over writing whatever is already there. (setq TmpDir (getvar "DwgPrefix" FH (open (strcat TmpDir "TEMP.DCL" "w" Ouptut the Dialog box contents for a list box by the name of DLIST. (write-line "DLIST : dialog {" FH (write-line (strcat "label=\"" Title "\";" FH (write-line (strcat ": list_box{key=\"list\"; width=" (itoa Wdt ";" FH (if Multi (write-line "multiple_select=true;" FH (write-line "}" FH (write-line "ok_only;" FH (write-line "}" FH (setq FH (close FH (load_dialog (strcat TmpDir "TEMP.DCL" Thank you! Please remember to fill out your evaluation card if you liked the class. Visit me on the