Axis Lisp and Utilities

Here is a lisp DCL program primarily to draw XY Axis or XYZ Axis. The user inputs values for min, max, tick length and tick increment. Circles instead of lines work well for the Z axis tick marks. In addition there are some simple routines for loading layers and textstyles. I put my fonttable program link here. The screen background can be changed to any gray value from white to black by inputting a value between 0-255. That gives us tools to make attractive graph presentations.

An Axis is a collection of lines. The easy way to draw lines in lisp is with the command function.

(defun demo1 ()
(setq pt1 (list 1 2 3)
pt2 (list 2 4 6))
(command “line” pt1 pt2 “”))

The line command is terminated with the empty quote. To add more line segments, add more points before the termination. This draws a triangle.

(defun demo2 ()
(setq pt1 (list 0 0 0)
pt2 (list 2 3 3)
pt3 (list 4 0 0))
(command “line” pt1 pt2 pt3 pt1 “”))

if the point are real numbers, not variables, the list can be quoted in-line. The line function also can use the “C” option to close the figure.

(defun demo3 ()
(command “line” ‘(0 0 0) ‘(2 3 3) ‘(4 0 0) “c” ))

a line subroutine can be used and re-used. this one is 2D. 3D can be implemented the same way.

(defun line1 (x1 y1 x2 y2)
(setq pt1 (list x1 y1 0)
pt2 (list x2 y2 0))
(command “line” pt1 pt2 “”))

(defun demo4 ()
(line1 0 0 2 3)
(line1 2 3 4 0)
(line1 4 0 0 0))

The visual lisp method to make a line is Addline. It works in either modelspace or populating a block (or paperspace). These spaces have to be set up as objects. Addline is a member of their class, so in VBA it becomes modelspace.Addline or blockdef.Addline. Once the necessary environment is made, the lines can be drawn as a block definition as easily as modelspace objects. Another advantage is that layer is just a property of the line. In more complex parametric drawing projects it is easier to specify the layer as a property of the line in the line creation subroutine than it is to change the current layer in the system before drawing the line. In this program the axis drawing is simple enough that it uses the current layer. The line subroutines below work as written for either modelspace or blockdefinition.

(defun demo5 ()
(vl-load-com)
(setq acadApp (vlax-get-acad-object))
(setq acadDoc (vla-get-ActiveDocument acadApp))
(setq ms (vla-get-ModelSpace acadDoc))

(line2 0 0 2 3 ms)
(line2 2 3 4 0 ms)
(line2 4 0 0 0 ms) )

(defun line2 (x1 y1 x2 y2 obj / pt1 pt2 lineobj)
(setq pt1 (vlax-3d-point x1 y1 0)
pt2 (vlax-3d-point x2 y2 0))
(setq lineObj (vla-AddLine obj pt1 pt2)) )

(defun demo6 ()
(vl-load-com)
(setq acadApp (vlax-get-acad-object))
(setq acadDoc (vla-get-ActiveDocument acadApp))
(setq ms (vla-get-ModelSpace acadDoc))

(line3 0 0 2 3 ms “Bold”)
(line3 2 3 4 0 ms “Center”)
(line3 4 0 0 0 ms “Hidden”) )

(defun line3 (x1 y1 x2 y2 obj lyr / pt1 pt2 lineobj)
(setq pt1 (vlax-3d-point x1 y1 0)
pt2 (vlax-3d-point x2 y2 0))
(setq lineobj (vla-AddLine obj pt1 pt2))
(vla-put-layer lineobj lyr) )

Here is the full Axis program with drawing utilities, sans the DCL file.


;; location of axis.lsp and dcl
 (setq axis_progdir "c:\\lisp\\axis\\")

(defun axis ()
   
   (load "c:\\LISP\\Table\\FontTable.LSP")
   (load "c:\\LISP\\Axis\\draw_axis.LSP")

 (setq dcl_id (load_dialog (strcat axis_progdir "axis.dcl")))
  (if (< dcl_id 0)
    (progn
      (alert "The Axis.DCL file could not be loaded.")
      (exit) ) )

  (if (not (new_dialog "axis" dcl_id))
    (progn
      (alert "DCL file loaded but not definition, internal problem with files" )
      (exit) )   )

  (set_axis_vars)

  (action_tile "resetform" "(set_axis_vars)")
  (action_tile "textstyles" "(loadstyles)")
  (action_tile "layers" "(loadlayers)")
  (action_tile "backcolor" "(backcolor)")

  (action_tile "xyaxis" "(savevars) (done_dialog 2)")
  (action_tile "xyzaxis" "(savevars) (done_dialog 3)")
  (action_tile "fonttable" "(done_dialog 4)")

  (action_tile "cancel" "(done_dialog 0)")

  (setq ddiag (start_dialog))

  (unload_dialog dcl_id)
   (if (= ddiag 2) (xy_axis) )
   (if (= ddiag 3) (xyz_axis) )
   (if (= ddiag 4) (fonttable) )
)


(defun set_axis_vars ()
    (set_tile "xmin" "-12")
    (set_tile "xmax" "12")
    (set_tile "xinc" "1")
    (set_tile "xtick" "0.5")

    (set_tile "ymin" "-12")
    (set_tile "ymax" "12")
    (set_tile "yinc" "1")
    (set_tile "ytick" "0.5")

    (set_tile "zmin" "-6")
    (set_tile "zmax" "6")
    (set_tile "zinc" "1")
    (set_tile "ztick" "0.25")
    
    (set_tile "blkname" "XY_Axis")
    (set_tile "bgcolor" "64")  )


(defun savevars()
  (setq xmin (atof (get_tile "xmin")))
  (setq xmax (atof (get_tile "xmax")))
  (setq xinc (atof (get_tile "xinc")))
  (setq xtick (atof (get_tile "xtick")))

  (setq ymin (atof (get_tile "ymin")))
  (setq ymax (atof (get_tile "ymax")))
  (setq yinc (atof (get_tile "yinc")))
  (setq ytick (atof (get_tile "ytick")))

  (setq zmin (atof (get_tile "zmin")))
  (setq zmax (atof (get_tile "zmax")))
  (setq zinc (atof (get_tile "zinc")))
  (setq ztick (atof (get_tile "ztick")))

  (setq blkname (get_tile "blkname")) )


  (defun xy_axis ( )
    (draw_xy_axis xmin xmax xinc xtick ymin ymax yinc ytick blkname))

  (defun xyz_axis ( )
    (draw_xyz_axis xmin xmax xinc xtick ymin ymax yinc ytick zmin zmax zinc ztick blkname))


 (defun loadstyles ( )
   (maketextstyle "Arial" "Arial.ttf")
   (maketextstyle "Arial Narrow" "ArialN.ttf")
   (maketextstyle "Calibri" "Calibri.ttf")
   (maketextstyle "Calibri Light" "CalibriL.ttf")
   (maketextstyle "Courier New" "Cour.ttf")
   (maketextstyle "Symbol" "Symbol.ttf")
   (setvar "textstyle" "Calibri")  )


 (defun loadlayers ( )
    (setq LT "continuous" LW 35)
    (makelayer "Axis" 1 LT LW)
    (makelayer "Directrix" 5 LT LW)
    (makelayer "Focus" 5 LT LW)
    (makelayer "Asymptote" 5 LT -3)
    (makelayer "Graph" 7 LT LW)

    (makelayer "1" 1 LT LW)
    (makelayer "2" 2 LT LW)
    (makelayer "3" 3 LT LW)
    (makelayer "4" 4 LT LW) 
    (makelayer "5" 5 LT LW)
    (makelayer "6" 6 LT LW)
    (makelayer "7" 7 LT LW)
    (makelayer "8" 8 LT LW)
    (makelayer "9" 9 LT LW)

    (setvar "clayer" "Axis")
    (setvar "LWDISPLAY" 1) )


 (defun backcolor ( )
	(setq rgbnum (atoi (get_tile "bgcolor")))
	(bkg rgbnum)  )


(defun setfonttable ( )
   (fonttable)  )


(DEFUN maketextstyle (name fontname)
(entmake (list (cons 0 "STYLE")
                 (cons 100 "AcDbSymbolTableRecord")
                 (cons 100 "AcDbTextStyleTableRecord")
                 (cons 2  name)
                 (cons 3  fontname)
                 (cons 70 0)
                 (cons 40 0.0)
                 (cons 41 1.0)
                 (cons 50 0.0)
                 (cons 71 0))) )


(DEFUN makelayer (name color Linetype Lineweight)
(entmake (list (cons 0 "LAYER")
                 (cons 100 "AcDbSymbolTableRecord")
                 (cons 100 "AcDbLayerTableRecord")
                 (cons 2  name)
                 (cons 70 0)
                 (cons 62 color)
                 (cons 6 Linetype)
                 (cons 290 1)
                 (cons 370 Lineweight)))  )


;modelspace background shades of gray
(defun bkg (rgbnum)
(setq hexnum (rgbhex rgbnum))

(setq acadobject (vlax-get-acad-object))
(setq acadpref (vlax-get-property acadobject 'preferences))
(setq acaddisp (vlax-get-property acadpref 'display))
(vlax-put-property acaddisp 'GraphicsWinmodelBackgrndColor hexnum) )


  (defun RGBhex (RGBnum / r g b)
    (setq r (lsh RGBnum 16))
    (setq g (lsh RGBnum 8))
    (setq b RGBnum)
    (+ r g b)  )

Draw_Axis.LSP is in a separate file. FontTable was posted previously. The Axis is created as a block. There is an editbox on the DCL form for the block name. When making blocks with Visual Lisp objects, if the block already exists, the new entities will simply be added to the definition. This is not what is intended, so a utility must be used to delete the old block definition. This is not possible if the block is inserted into the drawing, so another utility must be used to first delete instances, then the definition can be deleted. I found these routines on message boards. I wont post them since they are not mine. They are not long and work well. Be aware you need to devise your own solution or tolerance to this problem.


;draw_axis_lsp

(defun line (x1 y1 x2 y2 obj)
  (setq pt1 (vlax-3d-point x1 y1 0)
        pt2 (vlax-3d-point x2 y2 0))
  (setq lineObj (vla-AddLine obj pt1 pt2)) )


(defun linexyz (x1 y1 z1 x2 y2 z2 obj)
  (setq pt1 (vlax-3d-point x1 y1 z1)
        pt2 (vlax-3d-point x2 y2 z2))
  (setq lineObj (vla-AddLine obj pt1 pt2)) )


(defun draw_xtick (x ticklen obj)
  (setq pt1 (vlax-3d-point x (- (/ ticklen 2.0)) 0)
        pt2 (vlax-3d-point x (+ (/ ticklen 2.0)) 0))
   (setq lineObj (vla-AddLine obj pt1 pt2)) )

(defun draw_ytick (y ticklen obj)
  (setq pt1 (vlax-3d-point (- (/ ticklen 2.0)) y 0)
        pt2 (vlax-3d-point (+ (/ ticklen 2.0)) y 0))
   (setq lineObj (vla-AddLine obj pt1 pt2)) )

(defun circle (x1 y1 z1 rad obj / pt1 circleobj)
  (setq pt1 (vlax-3d-point x1 y1 z1))
   (setq circleobj (vla-AddCircle obj pt1 rad)) )

(defun draw_ztick (z ticklen obj)
  (setq pt1 (vlax-3d-point (- (/ ticklen 2.0)) 0 z)
        pt2 (vlax-3d-point (+ (/ ticklen 2.0)) 0 z))
   (setq lineObj (vla-AddLine obj pt1 pt2)) )


(defun x_axis (xmin xmax xinc ticklen obj)
(setq numpts (fix (1+ (/ (- xmax xmin) xinc))))
(line xmin 0 xmax 0 obj)
(setq inc 1)

(repeat numpts
 (setq x (+ xmin (* (- inc 1) xinc)))
 (setq inc (1+ inc))
 (draw_xtick x ticklen obj) )
 )


(defun y_axis (ymin ymax yinc ticklen obj)
(setq numpts (fix (1+ (/ (- ymax ymin) yinc))))
(line 0 ymin 0 ymax obj)
(setq inc 1)

(repeat numpts
 (setq y (+ ymin (* (- inc 1) yinc)))
 (setq inc (1+ inc))
 (draw_ytick y ticklen obj) )
 )


(defun z_axis (zmin zmax zinc ticklen obj)
(setq numpts (fix (1+ (/ (- zmax zmin) zinc))))
(linexyz 0 0 zmin  0 0 zmax obj)
(setq inc 1)

(repeat numpts
 (setq z (+ zmin (* (- inc 1) zinc)))
 (setq inc (1+ inc))
 (circle 0 0 z (/ ticklen 2) obj) )
 ;(ztick z ticklen obj) )
 )


(defun draw_xy_axis (xmin xmax xinc xtick ymin ymax yinc ytick blkname)
(vl-load-com)
   (setq acadApp (vlax-get-acad-object))
   (setq acadDoc (vla-get-ActiveDocument acadApp))
   (setq mSpace (vla-get-ModelSpace acadDoc))

    (del_blk blkname)
 
    (setq pt0 (vlax-3d-point 0 0 0))
  
    (setq blks (vla-get-Blocks acadDoc))
    (setq blkdef (vla-Add blks pt0 blkname))

    (x_axis xmin xmax xinc xtick blkdef)
    (y_axis ymin ymax yinc ytick blkdef)

   (setq blkref (vla-insertblock mspace pt0 blkname 1 1 1 0 ))
 )


(defun draw_xyz_axis (xmin xmax xinc xtick ymin ymax yinc ytick zmin zmax zinc ztick blkname)
(vl-load-com)
   (setq acadApp (vlax-get-acad-object))
   (setq acadDoc (vla-get-ActiveDocument acadApp))
   (setq mSpace (vla-get-ModelSpace acadDoc))

    (del_blk blkname)
 
    (setq pt0 (vlax-3d-point 0 0 0))
  
    (setq blks (vla-get-Blocks acadDoc))
    (setq blkdef (vla-Add blks pt0 blkname))

    (x_axis xmin xmax xinc xtick blkdef)
    (y_axis ymin ymax yinc ytick blkdef)
    (z_axis zmin zmax zinc ztick blkdef)

   (setq blkref (vla-insertblock mspace pt0 blkname 1 1 1 0 ))
 )

Curve Catalog

AutoLisp DCL Curve Graphing with curve “recipes” – equation, x value ranges, x value increment – saved and retrieved in an excel CSV file. Curve parameters in an excel list can be edited, sorted and re-organized. A sub-form Curve Catalog is popped up, data filled from the CSV file. User selects curve. Parameters are input to the Graph screen.

The code to Read the Excel.CSV file was written by Lee Mac and downloaded from his premier lisp site.
http://www.lee-mac.com/readcsv.html

Graphing mathematical equations with autolisp –
as an example,
(setq strfunc “(* a x x )”)
(setq a 2) returns 2
(setq x 2.1) returns 2.1
Strfunc returns “(* a x x )”
(read strfunc) returns (* A X X)
(eval (read strfunc)) returns 8.82

With this we can set up a function to return a result for any legal lisp statement and values x a b c d.
The function is passed as a string, strfunc. X is passed in as a Real. X will vary with each call from xmin to xmax by increment xinc,
The global vars for a_dim b_dim c_dim and d_dim do not vary.

(defun func_eval (x strfunc / a b c d)
(setq a a_dim b b_dim c c_dim d d_dim )
(setq result (eval (read strfunc))) )

The equations must be input in lisp form, prefix notation with the operator first in a list, expressions nested. As long as it is legal lisp, the above code will interpret it. The loop to draw the curve is basic lisp using the command function for either line or pline.

;; location of
;; graph.lsp and dcl
;; catalog.lsp and dcl
;; curve_catalog.csv

 (setq graph_progdir "c:\\lisp\\graph\\")


(defun c:graph ()
   ;catalog sub form program
  (load (strcat graph_progdir "catalog.lsp"))

 (setq dcl_id (load_dialog (strcat graph_progdir "graph.dcl")))
  (if (< dcl_id 0)
    (progn
      (alert "The graph.DCL file could not be loaded.")
      (exit) ) )

  (if (not (new_dialog "graph" dcl_id))
    (progn
      (alert "DCL file loaded but not definition, internal problem with files" )
      (exit) )   )

  (set_graph_vars)
  (action_tile "catalog" "(catalog) (set_graph_vars)")
  (action_tile "graphlines" "(savevars) (done_dialog 2)")
  (action_tile "graphpolylines" "(savevars) (done_dialog 3)")
  (action_tile "cancel" "(done_dialog 0)")

  (setq ddiag (start_dialog))
  (unload_dialog dcl_id)
  (if (= ddiag 2) (graphlines) )
  (if (= ddiag 3) (graphpolylines) )
)


(defun savevars	()
  (setq xmin (atof (get_tile "xmin")))
  (setq xmax (atof (get_tile "xmax")))
  (setq xinc (atof (get_tile "xinc")))
  (setq a_dim (atof (get_tile "a_dim")))
  (setq b_dim (atof (get_tile "b_dim")))
  (setq c_dim (atof (get_tile "c_dim")))
  (setq d_dim (atof (get_tile "d_dim")))
  (setq strfunc (get_tile "equation"))
)


(defun set_graph_vars ()
  (if xmin
    (set_tile "xmin" (rtos xmin 2 2))
    (set_tile "xmin" "-3.0")  )

  (if xmax
    (set_tile "xmax" (rtos xmax 2 2))
    (set_tile "xmax" "3.0")  )

  (if xinc
    (set_tile "xinc" (rtos xinc 2 2))
    (set_tile "xinc" "0.1")  )

  (if a_dim
    (set_tile "a_dim" (rtos a_dim 2 2))
    (set_tile "a_dim" "2")  )

  (if b_dim
    (set_tile "b_dim" (rtos b_dim 2 2))
    (set_tile "b_dim" "3")  )

  (if c_dim
    (set_tile "c_dim" (rtos c_dim 2 2))
    (set_tile "c_dim" "4")  )

  (if d_dim
    (set_tile "d_dim" (rtos d_dim 2 2))
    (set_tile "d_dim" "5")  )

    ;initial equation ax^2 + bx + c	
  (if (null strfunc)
    (set_tile "equation" "(+ (* a X X) (* b X) c)")
    (set_tile "equation" strfunc)  )
)


(defun func_eval (x strfunc / a b c d)
  (setq	a a_dim    b b_dim   c c_dim   d d_dim  )
  (setq result (eval (read strfunc))) )


(defun graphlines ()	;working with all global variables from savevars

  (setq numlines (/ (- xmax xmin) xinc))
  (setq i 1)
  (setq x1 xmin)
  (setq y1 (func_eval x1 strfunc))

  (repeat (fix numlines)

    (setq x2 (+ xmin (* i xinc)))
    (setq y2 (func_eval x2 strfunc))

    (setq pt1 (list x1 y1))
    (setq pt2 (list x2 y2))

    (command "line" pt1 pt2)
    (command)

    (setq x1 x2)
    (setq y1 y2)

    (setq i (1+ i))
  )
)


(defun graphpolylines ()    ;working with all global variables from savevars

  (setq numlines (/ (- xmax xmin) xinc))
  (setq x1 xmin)
  (setq y1 (func_eval x1 strfunc))
  (setq pt1 (list x1 y1))

  (command "pline" pt1)

  (setq i 1)
  (repeat (fix numlines)

    (setq x2 (+ xmin (* i xinc)))
    (setq y2 (func_eval x2 strfunc))

    (setq pt2 (list x2 y2))

    (command pt2)
    (setq i (1+ i))
  )
  (command)
)

Graph.DCL is straightforward

Each curve then is defined by its lisp string, xmin, xmax, xinc and the specific values of A B C and D if they are used. Those 8 variables can be saved in an Excel file, a list of curve recipes, and input to the Graph program through a nested dialog called Catalog. A couple extra information columns are added.

The Excel format is called CSV, Comma Separated Values. It is actually a text file. It can be loaded directly into a text editor. Autolisp has tools to read this format. Excel is very handy for displaying and managing it. Lee Mac’s program reads the table and returns a list of rows with each cell a separate item in the sub-list. With Lisp tools we can take that and re-display the CSV file in DCL list boxes.

I only make one list box active to user selection, the box with the legal lisp equation. the other boxes are for user reference. all list boxes are given the same height and handled the same way so the rows line up. When the user selects an equation, its parameters are written to the textboxes, however he has to select OK to dismiss the dialog and use the parameters. Selecting cancel will abandon the values and return the previous screen with the values unchanged.

Here is Catalog LSP, called from the button on Graph. much of its length is just from loading the 10 listboxes and dealing with variables.

;catalog_lsp called from graph_lsp


(defun catalog_setup ()
(setq file (strcat graph_progdir "curve_catalog.csv"))

;;*********************************************
;; Read CSV code from
;;http://www.lee-mac.com/readcsv.html
;;*********************************************
(setq data (LM:readcsv file))


(setq theList1  (mapcar 'car data))
(setq theList2  (mapcar 'cadr data))
(setq theList3  (mapcar 'caddr data))

(setq theList4  (mapcar '(lambda (abc) (nth 3 abc)) data))
(setq theList5  (mapcar '(lambda (abc) (nth 4 abc)) data))
(setq theList6  (mapcar '(lambda (abc) (nth 5 abc)) data))
(setq theList7  (mapcar '(lambda (abc) (nth 6 abc)) data))
(setq theList8  (mapcar '(lambda (abc) (nth 7 abc)) data))
(setq theList9  (mapcar '(lambda (abc) (nth 8 abc)) data))
(setq theList10  (mapcar '(lambda (abc) (nth 9 abc)) data))
)


(defun catalog ()
(catalog_setup)

  (setq dcl_id (load_dialog (strcat graph_progdir "catalog.dcl")))
  (if (< dcl_id 0)
    (progn  (alert "The catalog.DCL file could not be loaded.")
      (exit) ) )

  (if (not (new_dialog "catalog" dcl_id))
    (progn (alert "DCL file loaded but not definition, internal problem with files")
      (exit) ) )

  (set_catalog_vars)

  (start_list "list1" 3)
  (mapcar 'add_list theList1)
  (end_list)

  (start_list "list2" 3)
  (mapcar 'add_list theList2)
  (end_list)

  (start_list "list3" 3)
  (mapcar 'add_list theList3)
  (end_list)

  (start_list "list4" 3)
  (mapcar 'add_list theList4)
  (end_list)

  (start_list "list5" 3)
  (mapcar 'add_list theList5)
  (end_list)

  (start_list "list6" 3)
  (mapcar 'add_list theList6)
  (end_list)

  (start_list "list7" 3)
  (mapcar 'add_list theList7)
  (end_list)

  (start_list "list8" 3)
  (mapcar 'add_list theList8)
  (end_list)

  (start_list "list9" 3)
  (mapcar 'add_list theList9)
  (end_list)

  (start_list "list10" 3)
  (mapcar 'add_list theList10)
  (end_list)

  ;only list that is pickable is lisp equation
  (action_tile "list3" "(list-pick)")

  (action_tile "ok" "(savevars) (done_dialog 2)")
  (action_tile "cancel" "(done_dialog 0)")

  (setq ddiag (start_dialog))
  (unload_dialog dcl_id)

  ;(if (= ddiag 2) (nothing) )
  ;not required - savevars in ok button writes vars
  ;catalog button in graph lsp reads vars to screen 
 )


(defun savevars	()
  (setq xmin (atof (get_tile "xmin")))
  (setq xmax (atof (get_tile "xmax")))
  (setq xinc (atof (get_tile "xinc")))

  (setq a_dim (atof (get_tile "a_dim")))
  (setq b_dim (atof (get_tile "b_dim")))
  (setq c_dim (atof (get_tile "c_dim")))
  (setq d_dim (atof (get_tile "d_dim")))

  (setq strfunc (get_tile "equation"))
)


(defun list-pick ()
  (setq listval (get_tile "list3"))
  (setq curve_recipe (nth (atoi listval) data))

  (set_tile "equation" (nth 2 curve_recipe))
  (set_tile "xmin" (nth 3 curve_recipe))
  (set_tile "xmax" (nth 4 curve_recipe))
  (set_tile "xinc" (nth 5 curve_recipe))
  (set_tile "a_dim" (nth 6 curve_recipe))
  (set_tile "b_dim" (nth 7 curve_recipe))
  (set_tile "c_dim" (nth 8 curve_recipe))
  (set_tile "d_dim" (nth 9 curve_recipe))
 )

;code same as set_graph_vars, keeping them separate for now
(defun set_catalog_vars ()
  (if xmin
    (set_tile "xmin" (rtos xmin 2 2))
    (set_tile "xmin" "-3.0") )

  (if xmax
    (set_tile "xmax" (rtos xmax 2 2))
    (set_tile "xmax" "3.0") )

  (if xinc
    (set_tile "xinc" (rtos xinc 2 2))
    (set_tile "xinc" "0.1") )

  (if a_dim
    (set_tile "a_dim" (rtos a_dim 2 2))
    (set_tile "a_dim" "2") )

  (if b_dim
    (set_tile "b_dim" (rtos b_dim 2 2))
    (set_tile "b_dim" "3") )

  (if c_dim
    (set_tile "c_dim" (rtos c_dim 2 2))
    (set_tile "c_dim" "4") )

  (if d_dim
    (set_tile "d_dim" (rtos d_dim 2 2))
    (set_tile "d_dim" "5") )

    ;initial equation ax^2 + bx + c	
  (if (null strfunc)
    (set_tile "equation" "(+ (* a X X) (* b X) c)")
    (set_tile "equation" strfunc) )
 )

and last, the DCL file for Catalog, again much of its length is repeating operations for the many listboxes


catalog:dialog {
    	     label = "Curve Catalog";

             :row {
                    :list_box {
                                label ="Notes";
            	                  key = "list1";
            		       height = 35;
            		        width = 35;
            	      multiple_select = false;
            	     fixed_width_font = true;
            	                value = "0"; }

                   :list_box {
                                label ="Description";
            	                  key = "list2";
            		       height = 35;
            		        width = 35;
            	      multiple_select = false;
            	     fixed_width_font = true;
            	                value = "0"; }

                  :list_box {
                                label ="Function - *** PICK FROM THIS LIST ***";
            	                  key = "list3";
            		       height = 35;
            		        width = 50;
            	      multiple_select = false;
            	     fixed_width_font = true;
            	                value = "0"; }

                  :list_box {
                                label ="Xmin";
            	                  key = "list4";
            		       height = 35;
            		        width = 7;
            	      multiple_select = false;
            	     fixed_width_font = true;
            	                value = "0"; }

                  :list_box {
                                label ="Xmax";
            	                  key = "list5";
            		       height = 35;
            		        width = 7;
            	      multiple_select = false;
            	     fixed_width_font = true;
            	                value = "0"; }

                  :list_box {
                                label ="Xinc";
            	                  key = "list6";
            		       height = 35;
            		        width = 7;
            	      multiple_select = false;
            	     fixed_width_font = true;
            	                value = "0"; }

                  :list_box {
                                label ="A_Dim";
            	                  key = "list7";
            		       height = 35;
            		        width = 7;
            	      multiple_select = false;
            	     fixed_width_font = true;
            	                value = "0"; }

                  :list_box {
                                label ="B_Dim";
            	                  key = "list8";
            		       height = 35;
            		        width = 7;
            	      multiple_select = false;
            	     fixed_width_font = true;
            	                value = "0"; }

                  :list_box {
                                label ="C_Dim";
            	                  key = "list9";
            		       height = 35;
            		        width = 7;
            	      multiple_select = false;
            	     fixed_width_font = true;
            	                value = "0"; }

                  :list_box {
                                label ="D_Dim";
            	                  key = "list10";
            		       height = 35;
            		        width = 7;
            	      multiple_select = false;
            	     fixed_width_font = true;
            	                value = "0"; }
                }



           :row {
                      :edit_box {
                                   label = "Xmin";
                                     key = "xmin";}
                      :edit_box {
                                   label = "Xmax";
                                     key = "xmax";}
                      :edit_box {
                                   label = "Xinc";
                                     key = "xinc";}
               
                      :edit_box {
                                   label = "A_dim";
                                     key = "a_dim";}
                      :edit_box {
                                   label = "B_dim";
                                     key = "b_dim";}
                      :edit_box {
                                   label = "C_dim";
                                     key = "c_dim";}
                      :edit_box {
                                   label = "D_dim";
                                     key = "d_dim";}
                    }

               :row {
                      :edit_box {
                                   label = "Y = ";
                                     key = "equation";}
                     }
  
	     :row {
                    : button {
                               label = "OK";
            	                 key = "ok";
            		  is_default = true; }

                    : button {
                               label = "Cancel";
            	                 key = "cancel";
            	          is_default = false;
            	           is_cancel = true; }
                   }
    	
           }

AutoLisp DCL Equation Graphing

here is a start. equations have to be input in Lisp format. prototype, barely tested beyond initial ah ha!

Both line and polyline mode are enabled. The program remembers variables from run to run, so if you input a new equation, it will come up on next run.



(defun c:graph ()

  (setq dcl_id (load_dialog "c:\\lisp\\graph\\graph.dcl"))
  (if (< dcl_id 0)
    (progn
      (alert "The graph.DCL file could not be loaded.")
      (exit) ) )

  (if (not (new_dialog "graph" dcl_id))
    (progn
      (alert "DCL file loaded but not definition, internal problem with files")
      (exit) ) )

  (setgraphvars)

  (action_tile "graphlines" "(savevars) (done_dialog 2)")
  (action_tile "graphpolylines" "(savevars) (done_dialog 3)")
  (action_tile "cancel" "(done_dialog 0)")

  (setq ddiag (start_dialog))

  (unload_dialog dcl_id)

  (if (= ddiag 2)
    (graphlines) )
  
  (if (= ddiag 3)
    (graphpolylines) )
)


(defun savevars	()
  (setq xmin (atof (get_tile "xmin")))
  (setq xmax (atof (get_tile "xmax")))
  (setq xinc (atof (get_tile "xinc")))

  (setq a_dim (atof (get_tile "a_dim")))
  (setq b_dim (atof (get_tile "b_dim")))
  (setq c_dim (atof (get_tile "c_dim")))
  (setq d_dim (atof (get_tile "d_dim")))

  (setq str_equation (get_tile "equation"))
)


(defun setgraphvars ()
  (if xmin
    (set_tile "xmin" (rtos xmin 2 2))
    (set_tile "xmin" "-3.0") )

  (if xmax
    (set_tile "xmax" (rtos xmax 2 2))
    (set_tile "xmax" "3.0") )

  (if xinc
    (set_tile "xinc" (rtos xinc 2 2))
    (set_tile "xinc" "0.1") )

  (if a_dim
    (set_tile "a_dim" (rtos a_dim 2 2))
    (set_tile "a_dim" "2") )

  (if b_dim
    (set_tile "b_dim" (rtos b_dim 2 2))
    (set_tile "b_dim" "3") )

  (if c_dim
    (set_tile "c_dim" (rtos c_dim 2 2))
    (set_tile "c_dim" "4") )

  (if d_dim
    (set_tile "d_dim" (rtos d_dim 2 2))
    (set_tile "d_dim" "5") )
  
			;initial equation ax^2 + bx + c	
  (if (null str_equation)
    (set_tile "equation" "(+ (* a X X) (* b X) c)")
    (set_tile "equation" str_equation) ) )


(defun resetgraph ()
  (set_tile "xmin" "-3.0")
  (set_tile "xmax" "3.0")
  (set_tile "xinc" "0.1")

  (set_tile "a_dim" "2")
  (set_tile "b_dim" "3")
  (set_tile "c_dim" "4")
  (set_tile "d_dim" "5")

  (setq str_equation "(+ (* a X X) (* b X) c)") ;initial equation
  (set_tile "equation" str_equation)	; ax^2 + bx + c
)


(defun func_eval (x strfunc / a b c d)
  (setq	a a_dim   b b_dim   c c_dim   d d_dim )
  (setq result (eval (read strfunc)))
)


(defun graphlines ()	;working with all global variables from savevars
		
  (setq strfunc str_equation)	; could clean this up

  (setq numlines (/ (- xmax xmin) xinc))
  (setq i 1)
  (setq x1 xmin)
  (setq y1 (func_eval x1 strfunc))

  (repeat (fix numlines)

    (setq x2 (+ xmin (* i xinc)))
    (setq y2 (func_eval x2 strfunc))

    (setq pt1 (list x1 y1))
    (setq pt2 (list x2 y2))

    (command "line" pt1 pt2)
    (command)

    (setq x1 x2)
    (setq y1 y2)

    (setq i (1+ i))
  )
)

		
(defun graphpolylines ()   ;working with all global variables from savevars

  (setq strfunc str_equation)	; eval read strfunc

  (setq numlines (/ (- xmax xmin) xinc))
  (setq x1 xmin)
  (setq y1 (func_eval x1 strfunc))
  (setq pt1 (list x1 y1))

  (command "pline" pt1)

  (setq i 1)
  (repeat (fix numlines)

    (setq x2 (+ xmin (* i xinc)))
    (setq y2 (func_eval x2 strfunc))

    (setq pt2 (list x2 y2))

    (command pt2)
    (setq i (1+ i))
  )

  (command)

)

Graphs below are cos, sin and cos * sin
(cos X) White
(sin X) Red
(* (sin X) (cos X)) Blue