Adding Straight Line Segments

Straight objects are used in a variety of drawings created by drafters and engineers. You can use a straight object to represent the following:

• The top of a bolt head
• The tooth of a gear
• A wire in a wiring diagram
• The edge of a student desk
• The face of a wall for a building

Lines are straight objects with a defined start point and endpoint and are represented by the AcadLine object. The AddLine function allows you to create a line object drawn between two points. The following shows the syntax of the AddLine function:

retVal = object.AddLine(startPoint, endPoint)

Its arguments are as follows:

1. retVal The retVal argument represents the new AcadLine object returned by the AddLine function.
2. object The object argument represents the AcadModelSpace collection object.
3. startPoint The startPoint argument is an array of three doubles that defines the start point of the new line.
4. endPoint The endPoint argument is an array of three doubles that defines the endpoint of the new line.

The following code statements add a new line object to model space (see Figure 4.2):

' Defines the start and endpoint for the line
Dim dStartPt(2) As Double, dEndPt(2) As Double
dStartPt(0) = 0: dStartPt(1) = 0: dStartPt(2) = 0
dEndPt(0) = 5: dEndPt(1) = 5: dEndPt(2) = 0
Dim oLine As AcadLine
Set oLine = ThisDrawing.ModelSpace.AddLine(dStartPt, dEndPt)

Using the AcadLine object returned by the AddLine function, you can obtain information about and modify the line's properties. In addition to the properties that the AcadLine object shares in common with the AcadEntity object, you can use the properties listed in Table 4.5 when working with an AcadLine object.

Working with Curved Objects

Straight objects are used in many designs, but they aren't the only objects. Curved objects are used to soften the edges of a design and give a design a more organic look. You can use a curved object to represent any of the following:

• A hole in a plate
• A fillet on a metal bracket
• A round edge on the top of a desk
• A cross section of a shaft or hub

I discuss how to create and modify circles in the upcoming sections.

Creating and Modifying Circles

Circles are one of the most commonly used curved objects in mechanical designs, but they are less frequently used in architectural and civil designs. Drill holes in the top view of a model, the center of a gear, or the grommet in the side of a desk are typically circular and are drawn using circles. Circles in a drawing are represented by the AcadCircle object in the AutoCAD Object library. The AddCircle function allows you to create a circle object based on a center point and radius value, and the function returns an AcadCircle object that represents the new circle. The following shows the syntax of the AddCircle function:

retVal = object.AddCircle(centerPoint, radius)

Its arguments are as follows:

1. retVal The retVal argument represents the new AcadCircle object returned by the AddCircle function.
2. object The object argument represents the AcadModelSpace collection object.
3. centerPoint The centerPoint argument is an array of three doubles that defines the center point of the new circle.
4. radius The radius argument is a double that specifies the radius of the new circle. If you know the diameter of the circle you want to create, divide that value in half to get the radius for the circle.

The following code statements add a new circle object to model space (see Figure 4.3):

' Defines the center point for the circle object
Dim dCenPt(2) As Double
dCenPt(0) = 2.5: dCenPt(1) = 1: dCenPt(2) = 0
' Adds the circle object to model space with a radius of 4
Dim oCirc As AcadCircle
Set oCirc = ThisDrawing.ModelSpace.AddCircle(dCenPt, 4)

The properties and methods of the AcadCircle object returned by the AddCircle function can be used to obtain information about and modify the circle. An AcadCircle object shares properties and methods in common with the AcadEntity object, but it has additional properties that describe the circle object. Table 4.6 lists the properties specific to the AcadCircle object.

Property	Description
Area	Returns a double that represents the calculated area of the circle.
Center	Specifies the center point of the circle. That value is expressed as an array of three doubles.
Circumference	Returns a double that represents the circumference of the circle.
Diameter	Specifies the diameter of the circle; the value is a double.
Normal	Specifies the normal vector of the line. The normal vector is an array of three doubles that defines the positive Z-axis for the circle.
Radius	Specifies the radius of the circle; the value is a double.
Thickness	Specifies the thickness assigned to the circle; the value must be numeric. The default is 0; anything greater than 0 results in the creation of a 3D cylinder object.

Adding and Modifying Arcs

Fillets and rounded corners are common in many types of designs, and they are drawn using arcs. Arcs are partial circles represented by the AcadArc object. An arc is added to a drawing with the AddArc function. Unlike drawing arcs with the arc command, which offers nine options, the AddArc function offers only one approach to adding an arc, and that is based on a center point, two angles (start and end), and a radius. The AddArc function returns an AcadArc object that represents the new arc added to the drawing. The following shows the syntax of the AddArc function:

retVal = object.AddArc(centerPoint, radius, startAngle, endAngle)

Its arguments are as follows:

1. retVal The retVal argument represents the new AcadArc object returned by the AddArc function.
2. object The object argument represents the AcadModelSpace collection object.
3. centerPoint The centerPoint argument is an array of three doubles that defines the center point of the new arc.
4. radius The radius argument is a double that specifies the radius of the new arc.
5. startAngle and endAngle The startAngle and endAngle arguments are doubles that specify the starting and end angle of the new arc, respectively. A start angle larger than the end angle results in the arc being drawn in a counterclockwise direction. Angles are measured in radians.

The following code statements add a new arc object to model space (see Figure 4.4):

' Defines the center point for the arc object
Dim dCenPt(2) As Double
dCenPt(0) = 2.5: dCenPt(1) = 1: dCenPt(2) = 0
' Sets the value of PI
Dim PI As Double
PI = 3.14159265
' Adds the arc object to model space with a radius of 4
Dim oArc As AcadArc
Set oArc = ThisDrawing.ModelSpace.AddArc(dCenPt, 4, PI, 0)

The AcadArc object returned by the AddArc function can be used to obtain information about and modify the object's properties and methods. In addition to the properties that the AcadArc object shares in common with the AcadEntity object, you can use the properties listed in Table 4.7 when working with an AcadArc object.

Property	Description
ArcLength	Returns a double that represents the length along the arc.
Area	Returns a double that represents the calculated area of the arc.
Center	Specifies the center point of the arc. The value is expressed as an array of three doubles.
EndAngle	Specifies a double that represents the end angle of the arc.
EndPoint	Returns an array of doubles that represents the endpoint of the arc.
Normal	Specifies the normal vector of the line. The normal vector is an array of three doubles that defines the positive Z-axis for the arc.
Radius	Specifies the radius of the arc; the value is a double.
StartAngle	Specifies a double that represents the start angle of the arc.
StartPoint	Returns an array of doubles that represents the start point of the arc.
Thickness	Specifies the thickness assigned to the circle; the value must be numeric. The default is 0; anything greater than 0 results in the creation of a curved 3D object.
TotalAngle	Returns a double that represents the angle of the arc: the end angle minus the start angle.

Working with Polylines

Polylines are objects that can be made up of multiple straight and/or curved segments. Although lines and arcs drawn end to end can look like a polyline, polylines are more efficient to work with. Because a polyline is a single object made up of multiple segments, it is easier to modify. For example, all segments of a polyline are offset together instead of individually. If you were to offset lines and arcs that were drawn end to end, the resulting objects wouldn't be drawn end to end like the original objects (see Figure 4.5).

There are two types of polylines that you can create and modify:

1. Polyline Legacy polylines were available in AutoCAD R13 and earlier releases, and they are still available in AutoCAD R14 and later releases. This type of polyline object supports 3D coordinate values, but it uses more memory and increase the size of a drawing file.
2. Lightweight Polyline Lightweight polylines, or LWPolylines, were first introduced in AutoCAD R14. They are more efficient in memory and require less space in a drawing file. Lightweight polylines support only 2D coordinate values.

Legacy polylines are represented by the AcadPolyline object type and can be added to a drawing with the AddPolyline function. LWPolylines are represented by the AcadLWPolyline object type and can be added to a drawing with the AddLightWeightPolyline function. The AddPolyline and AddLightWeightPolyline functions both require you to specify a list of vertices.

A vertices list is defined using an array of doubles. The number of elements in the array varies by the type of polyline you want to create or modify. To create an AcadPolyline object, you define an array of doubles in multiples of three, whereas an array of doubles must be in multiples of two to create an AcadLWPolyline object. For example, an AcadPolyline object with three vertices would require an array with nine elements (three elements × three vertices). For an LWPolyline, each vertex requires two elements in an array, so an AcadLWPolyline object with three vertices would require a vertices list with six elements (two elements × three vertices).

The following shows an example of a six-element array that defines three 2D points representing the corners of a triangle:

' Defines a six element array of doubles
Dim dVecList(5) As Double
' Sets the first corner
dVecList(0) = 0#: dVecList(1) = 0#
' Sets the second corner
dVecList(2) = 3#: dVecList(3) = 0#
' Sets the third corner
dVecList(4) = 1.5: dVecList(5) = 2.5981

The following shows the syntax of the AddLightWeightPolyline and AddPolyline functions:

retVal = object.AddLightWeightPolyline(vecList)
retVal = object.AddPolyline(vecList)

The arguments are as follows:

1. retVal The retVal argument represents the new AcadLWPolyline or AcadPolyline object returned by the AddLightWeightPolyline or AddPolyline function.
2. Object The object argument represents the AcadModelSpace collection object.
3. vecList The vecList argument is an array of doubles that defines the vectors of the polyline. For the AddLightWeightPolyline function, the array must contain an even number of elements since each vertex is defined by two elements. Specify an array in three-element increments when using the AddPolyline function since each vertex is defined by three elements.

The following code statements add a new lightweight polyline object to model space (see Figure 4.6):

' Adds a lightweight polyline
Dim oLWPoly As AcadLWPolyline
Set oLWPoly = ThisDrawing.ModelSpace.AddLightWeightPolyline(dVecList)

Using the AcadLWPolyline or AcadPolyline object returned by the AddLightWeightPolyline or AddPolyline function, you can obtain information about and modify the polyline's properties. In addition to the properties that the AcadLWPolyline or AcadPolyline object share in common with the AcadEntity object, you can use the properties listed in Table 4.8 when working with an AcadLWPolyline or AcadPolyline object.

In addition to the properties listed in Table 4.8, an AcadLWPolyline or AcadPolyline object contains methods that are specific to polylines. Table 4.9 lists the methods that are unique to polylines.

Deleting Objects

All graphical and most nongraphical objects can be removed from a drawing when they are no longer needed. The only objects that can't be removed are any nongraphical objects that are referenced by a graphical object, such as a text or dimension style, and nongraphical objects that represent symbol tables, such as the Layers and Blocks symbol tables. The Delete method is used to remove—or erase—an object. The method doesn't accept any arguments. If an object can't be removed, an error is generated. I explain how to trap and handle errors in Chapter 13, “Handling Errors and Deploying VBA Projects.”

The following code statement removes the first object in model space:

' Removes the first object in model space
ThisDrawing.ModelSpace(0).Delete

Copying and Moving Objects

The copy and move commands are used to duplicate and relocate objects in a drawing. When working with the AutoCAD Object library, use the Copy function to duplicate an object. The Copy function doesn't accept any arguments, but it does return a reference to the new duplicate object. The Move method can be used to relocate an object. It expects two arrays of three doubles that define the base and destination points to control the distance and angle at which the object should be moved.

The following code statements draw a circle, duplicate the circle, and then move the duplicated circle 5 units along the X-axis in the positive direction:

' Defines the center point for the circle
Dim dCenPt(2) As Double
dCenPt(0) = 5: dCenPt(1) = 5: dCenPt(2) = 0
' Adds a new circle to model space
Dim oCirc As AcadCircle
Set oCirc = ThisDrawing.ModelSpace.AddCircle(dCenPt, 2)
' Creates a copy of the circle
Dim oCircCopy As AcadCircle
Set oCircCopy = oCirc.Copy
' Moves the circle 5 units along the X axis
Dim dToPt(2) As Double
dToPt(0) = oCircCopy.Center(0) + 5
dToPt(1) = oCircCopy.Center(1)
dToPt(2) = oCircCopy.Center(2)
oCircCopy.Move dCenPt, dToPt

Rotating Objects

The angle and orientation of an object can be changed by rotating the object around a base point or axis. Rotating an object around a base point is performed with the Rotate method, whereas rotating an object around an axis is performed with the Rotate3D method. I discuss the Rotate3D method in Bonus Chapter 2 on the companion website. The base point you pass to the Rotate method must be defined as an array of three doubles. The angle in which the object is rotated must be expressed in radians.

The following code statements draw a line from 5,5 to 7,9 and then create a copy of the line. The new line object that is copied is then rotated 90 degrees to a value of 1.570796325 radians (see Figure 4.8):

' Defines the start and endpoints of the line
Dim dStartPt(2) As Double, dEndPt(2) As Double
dStartPt(0) = 5: dStartPt(1) = 5: dStartPt(2) = 0
dEndPt(0) = 7: dEndPt(1) = 9: dEndPt(2) = 0
' Adds a new line to model space
Dim oLine As AcadLine
Set oLine = ThisDrawing.ModelSpace.AddLine(dStartPt, dEndPt)
' Copies the line
Dim oLineCopy As AcadLine
Set oLineCopy = oLine.Copy
' Rotates the copied line by 1.570796325 radians
oLineCopy.Rotate dStartPt, 1.570796325

The angular measurement of radians isn't as frequently used as degrees, but all angular values in a drawing are stored as radians; this is why the Rotate method expects radians. Radians are also expected or returned by most methods or properties in the AutoCAD Object library. Listing 4.1 shows two custom functions that can be used to convert degrees to radians and radians to degrees.

Here are a few examples of using the custom functions in Listing 4.1:

Dim dAngle As Double
' Converts 1.570796325 radians to 90 degrees
dAngle = Radians2Degrees(PI / 2)
' Converts 180 degrees to 3.14159265 radians
dAngle = Degrees2Radians(180)

Creating the DrawPlate Project

The following steps explain how to create a project named DrawPlate and to save it to a file named drawplate.dvb:

1. On the ribbon, click Manage tab Applications panel title bar and then click VBA Manager (or at the Command prompt, type vbaman and press Enter).
2. When the VBA Manager opens, click New.

   The new project is added to the list with a default name of ACADProject and a location of Global1, Global2, and so on based on how many projects have been created in the current AutoCAD session.

3. Select the new project from the Projects list and click Save As.
4. When the Save As dialog box opens, browse to the MyCustomFiles folder within the Documents (or My Documents) folder, or the location you are using to store custom program files.
5. In the File Name text box, type drawplate and click Save.
6. In the VBA Manager dialog box, click Visual Basic Editor.

The next steps explain how to change the project name from ACADProject to DrawPlate:

1. When the VBA Editor opens, select the project node labeled ACADProject from the Project Explorer.
2. In the Properties window, select the field named (Name) and double-click in the text box adjacent to the field.
3. In the text box, type DrawPlate and press Enter.

   

4. On the menu bar, click File Save.

Creating the Utilities Class

Separating the custom functions you create into logical groupings can make debugging code statements easier and allow you to reuse code in other products. Custom classes are one way of sharing functions and protecting global variables from the functions of your main project. One of the benefits of using a custom class over just a code module is that you gain the advantage of type-ahead in the Visual Basic Editor, which reduces the amount of text you need to type.

In these steps, you add a new custom class module named clsUtilities to the DrawPlate project:

1. On the menu bar, click Insert Class Module.
2. In the Project Explorer, select the new module named Class1.
3. In the Properties window, change the current value of the (Name) property to clsUtilities.
4. On the menu bar, click File Save.

The clsUtilities class module will contain functions that define common and reusable functions for use with the main function of the DrawPlate project along with other projects later in this book. The following steps add two functions to the clsUtilities class that are used to work with system variables.

Working with one system variable at a time isn't always efficient when you need to set or restore the values of multiple system variables. You will define two functions named GetSysvars and SetSysvars. The GetSysvars function will return an array of the current values for multiple system variables, and the SetSysvars function will be used to set the values of multiple system variables.

The following steps explain how to add the GetSysvars and SetSysvars functions:

1. In the Project Explorer, double-click the clsUtilities component.
2. In the text editor area of the clsUtilities component, type the following. (The comments are here for your information and don't need to be typed.)

   ' GetSysvars function returns an array of the current values
   ' for each system variable in the array it is passed.
   Public Function GetSysvars(sysvarNames) As Variant
     Dim nIdxTotal As Integer
     nIdxTotal = UBound(sysvarNames)
     Dim aVals() As Variant
     ReDim aVals(UBound(sysvarNames) - LBound(sysvarNames))
     Dim nCnt As Integer
     For nCnt = LBound(sysvarNames) To UBound(sysvarNames)
       aVals(nCnt) = ThisDrawing.GetVariable(sysvarNames(nCnt))
     Next
     GetSysvars = aVals
   End Function
   ' SetSysvars function sets the values of the system variables
   ' in the array that the function is passed.
   ' Function expects two arrays.
   Public Sub SetSysvars(sysvarNames, sysvarValues)
     Dim nCnt As Integer
     For nCnt = LBound(sysvarNames) To UBound(sysvarNames)
       ThisDrawing.SetVariable sysvarNames(nCnt), sysvarValues(nCnt)
     Next
   End Sub

3. Click File Save.

New graphical objects must be added to model space, paper space, or a block definition. In most situations, you want to add new objects to the current layout. You can create custom functions to combine multiple code statements and reduce the amount of code that needs to be otherwise entered. The following steps add three functions to the clsUtilities class that can be used to create a closed polyline and circle in the current layout, and a new layer.

1. In the text editor area of the clsUtilities component, type the following. (The comments are here for your information and don't need to be typed.)

   ' CreateRectangle function draws a closed LWPolyline object.
   ' Function expects an array that represents four points,
   ' but can accept more points.
   Public Function CreateRectangle(ptList As Variant) As AcadLWPolyline
     Set CreateRectangle = ThisDrawing.ActiveLayout.Block. _
                           AddLightWeightPolyline(ptList)
     CreateRectangle.Closed = True
   End Function
   ' CreateCircle function draws a Circle object.
   ' Function expects a center point and radius.
   Public Function CreateCircle(cenPt As Variant, circRadius) As AcadCircle
     Set CreateCircle = ThisDrawing.ActiveLayout.Block. _
                        AddCircle(cenPt, circRadius)
   End Function
   ' CreateLayer function creates a layer and returns an AcadLayer object.
   ' Function expects a layer name and color.
   Public Function CreateLayer(sName As String, _
                               nClr As ACAD_COLOR) As AcadLayer
     On Error Resume Next
     ' Try to get the layer first and return it if it exists
     Set CreateLayer = ThisDrawing.Layers(sName)
     ' If layer doesn't exist create it
     If Err Then
       Err.Clear
       Set CreateLayer = ThisDrawing.Layers.Add(sName)
       CreateLayer.color = nClr
     End If
   End Function

2. Click File Save.

Defining the CLI_DrawPlate Function

The main function of the DrawPlate project draws a rectangular mounting plate with four bolt holes. The outside edge of the mounting plate is defined using a closed lightweight polyline that is drawn using the CreateRectangle function defined in the clsUtilities class. Each of the bolt holes is drawn using the CreateCircle function of the clsUtilities class. Since objects in a drawing are organized using layers, you will place the rectangle and circles on different layers; the layers will be added to the drawing with the CreateLayer function.

In these steps, you add a new custom module named basDrawPlate to the DrawPlate project:

1. On the menu bar, click Insert Module.
2. In the Project Explorer, select the new module named Module1.
3. In the Properties window, change the current value of the (Name) property to basDrawPlate.
4. On the menu bar, click File Save.

The following steps explain how to add the CLI_DrawPlate function, which is the macro users will use to create the mounting plate:

1. In the Project Explorer, double-click the basDrawPlate component.
2. In the text editor area of the basDrawPlate component, type the following:

   Private myUtilities As New clsUtilities

   The clsUtilities.cls file code statement defines a global variable named myUtilities. The myUtilities variable is then assigned a new instance of the clsUtilities class that you defined earlier. When you want to reference a function defined in the clsUtilities class, you will use the myUtilities variable.

3. In the text editor area of the basDrawPlate component, press Enter and type the following. (The comments are here for your information and don't need to be typed.)

   Public Sub CLI_DrawPlate()
     Dim oLyr As AcadLayer
     On Error Resume Next
     ' Store the current value of the system variables to be restored later
     Dim sysvarNames As Variant, sysvarVals As Variant
     sysvarNames = Array("nomutt", "clayer", "textstyle")
     sysvarVals = myUtilities.GetSysvars(sysvarNames)
     ' Set the current value of system variables
     myUtilities.SetSysvars sysvarNames, Array(0, "0", "STANDARD")
     ' Define the width and height for the plate
     Dim dWidth As Double, dHeight As Double
     dWidth = 5#
     dHeight = 2.75
     Dim basePt(2) As Double
     basePt(0) = 0: basePt(1) = 0: basePt(2) = 0
     ' Create the layer named Plate or set it current
     Set oLyr = myUtilities.CreateLayer("Plate", acBlue)
     ThisDrawing.ActiveLayer = oLyr
     ' Create the array that will hold the point list
     ' used to draw the outline of the plate
     Dim dPtList(7) As Double
     dPtList(0) = basePt(0): dPtList(1) = basePt(1)
     dPtList(2) = basePt(0) + dWidth: dPtList(3) = basePt(1)
     dPtList(4) = basePt(0) + dWidth: dPtList(5) = basePt(1) + dHeight
     dPtList(6) = basePt(0): dPtList(7) = basePt(1) + dHeight
     ' Draw the rectangle
     myUtilities.CreateRectangle dPtList
     ' Create the layer named Holes or set it current
     Set oLyr = myUtilities.CreateLayer("Holes", acRed)
     ThisDrawing.ActiveLayer = oLyr
     ' Define the center points of the circles
     Dim cenPt1(2) As Double, cenPt2(2) As Double
     Dim cenPt3(2) As Double, cenPt4(2) As Double
     cenPt1(0) = 0.5: cenPt1(1) = 0.5: cenPt1(2) = 0
     cenPt2(0) = 4.5: cenPt2(1) = 0.5: cenPt2(2) = 0
     cenPt3(0) = 0.5: cenPt3(1) = 2.25: cenPt3(2) = 0
     cenPt4(0) = 4.5: cenPt4(1) = 2.25: cenPt4(2) = 0
     ' Draw the four circles
     myUtilities.CreateCircle cenPt1, 0.1875
     myUtilities.CreateCircle cenPt2, 0.1875
     myUtilities.CreateCircle cenPt3, 0.1875
     myUtilities.CreateCircle cenPt4, 0.1875
     ' Restore the saved system variable values
     myUtilities.SetSysvars sysvarNames, sysvarVals
   End Sub

4. Click File Save.

Running the CLI_DrawPlate Function

Now that the CLI_DrawPlate function has been defined with the necessary code statements to draw the mounting plate, it can be executed from the AutoCAD user interface. In these steps, you run the CLI_DrawPlate function from the Macros dialog box.

1. Switch to AutoCAD by clicking on its icon in the Windows taskbar or by clicking View AutoCAD from the menu bar in the Visual Basic Editor.
2. In AutoCAD, at the Command prompt, type vbarun and press Enter.
3. When the Macros dialog box opens, select the DrawPlate.dvb!basDrawPlate.CLI_DrawPlate macro from the list and click Run.

   The new mounting plate is drawn, as shown in Figure 4.9. The mounting plate measures 5×2.75, which was defined in the CLI_DrawPlate function. In Chapter 5, you will learn to accept user input to control the size of the mounting plate that should be drawn.

   If you don't see the mounting plate, use the zoom command and zoom to the extents of the drawing area.

Exporting the Utilities Class

The functions in the clsUtilities class can be used in other projects. By exporting the class module out of the DrawPlate project, you can then import it into other projects. Class modules aren't the only components that can be exported from a project; you can export code modules and User Forms that define dialog boxes in a project as well.

The following steps explain how to export the clsUtilities class module from the drawplate.dvb file:

1. In the VBA Editor, in the Project Explorer, right-click the clsUtilities component and choose Export File.
2. When the Export File dialog box opens, browse to the MyCustomFiles folder.
3. Keep the default filename of clsUtilities.cls and click Save.

   The clsUtilities.cls file is exported from the DrawPlate project.