I gave a high-level presentation about automating drawings in Inventor at AU 2007. The most useful information from that presentation is the sample programs, but apparently they aren’t available from the AU website since I’ve had a couple of requests for them recently. Remember this is from a couple of years ago and Inventor now supports some things that it didn’t then. Here’s a download that contains the original class handout plus all of the sample programs.
Brian Ekins
October 14, 2009
October 01, 2009
Visual Basic 6 Add-Ins and 64-Bit
I saw a question in the customization newsgroup where someone has an Add-In written using Visual Basic 6 and wants to use that add-in with the 64-bit version of Inventor. In doing this there are some issues to be aware of:
- 64-bit Windows can run both 32-bit and 64-bit applications (exe’s and dll’s).
- Visual Basic 6 can only create 32-bit applications (exe’s and dll’s).
- A 64-bit exe can only load 64-bit dll’s. It cannot use 32-bit dll’s.
In this case, Inventor is a 64-bit exe and the Add-In is a dll. A VB 6 Add-In will be a 32-bit dll. Based on the statements above, this means that it can’t be used by 64-bit Inventor since that results in a 64-bit exe trying to load a 32-bit dll. There are two possible solutions; change the add-in to be an exe instead of a dll or convert the add-in to .Net where you have the ability to create a 64-bit dll.
Changing a VB 6 Add-In from a DLL to an EXE
Changing an existing VB 6 Add-In from a dll to an exe is very easy. Open the project and use the Properties command in the Project menu to display the dialog shown below. Change the project type from “AcitveX DLL” to “ActiveX EXE”. Recompile and now you have an exe Add-in. However, continue reading…
There are two things to be aware of when converting a dll Add-In to an exe Add-In. The first is that the performance of the exe Add-In won’t be as good as the dll Add-In. A dll Add-In is loaded into Inventor’s process space and API calls are made directly. An exe Add-In runs in its own process space and is separate from Inventor. This requires API calls to be marshaled between the two processes which is not as efficient. How much slower it is will differ from Add-In to Add-In because it depends on what kind of API calls you’re making.
The second issue is more of a problem and is a side-effect of the fact that data has to be marshaled between the two processes. Inventor’s API relies on Microsoft technology to do the marshaling between the two processes. Unfortunately, this technology doesn’t support the marshaling of bitmap data. This means that any Inventor API calls you make where an IPictureDisp object is passed as an argument won’t work with an exe Add-In.
Their are only a few calls in Inventor’s API that work with bitmaps but one of these is a function that most Add-Ins use. That’s the AddButtonDefinition method that’s used to create a button for the user-interface. An exe Add-In won’t be able to have icons on its buttons because of this limitation. Icons are optional so you can remove those arguments from the AddButtonDefinition call and then the Add-In should function correctly but you’ll only have text on the button instead of an icon.
Another area of the API where a bitmap is used is when getting or setting the thumbnail image for a document. This will fail for an exe Add-In.
Using the VB6 version of the SimpleAddIn sample that’s delivered as part of Inventor’s SDK, here are the changes that are required to make it work on 64-bit Windows.
- Change the project type to ActiveX EXE, as explained above.
- Comment out the lines that load the bitmaps for the icons.
Dim oIcon1 As IPictureDisp
' Dim oIcon2 As IPictureDisp
' Dim oIcon3 As IPictureDisp
' Set oIcon1 = LoadPicture(App.Path & "\AddSlotOption.ico")
' Set oIcon2 = LoadPicture(App.Path & "\Slot.ico")
' Set oIcon3 = LoadPicture(App.Path & "\Toggle.ico") - Edit the lines where the buttons are created to remove the icons. The following three lines (please pay attention to the line wrapping) are changed from this: Set oButtonDefAddOption = ..., "Add slot option", oIcon1, oIcon1)
Set oButtonDefDrawSlot = ... , "Draw Slot", oIcon2, oIcon2)
Set oButtonDefToggleSlotState = ..., "Toggle Slot State", oIcon3, oIcon3)to this:
Set oButtonDefAddOption = ..., "Add slot option")
Set oButtonDefDrawSlot = ... , "Draw Slot")
Set oButtonDefToggleSlotState = ..., "Toggle Slot State")This is possible because the icon arguments are optional.
- Compile the Add-In to create the EXE version of it and run the the registration file to register it, (AddInSample.reg in the case of the example Add-In).
- Run Inventor to make sure the Add-In is loading and working correctly on a 32-bit system.
The tricky part now is getting this Add-In to register correctly on a 64-bit system. Since it’s a 32-bit application, by default it will register itself in the 32-bit section of the registry on a 64-bit system, but Inventor will only look for Add-Ins in the main section of the registry, which is the 64-bit section in this case. The following steps illustrate one way to get the registration in the correct area on the 64-bit system. - Find out the CLSID for your Add-In. There are two ways to find this out. If you’re already using a .reg file to register your Add-In, it will be in that. Here’s the second line from the AddInSample.reg file that’s part of the sample.
[HKEY_CLASSES_ROOT\CLSID\{DB59D9A7-EE4C-434A-BB5A-F93E8866E872}]
The “{DB59D9A7-EE4C-434A-BB5A-F93E8866E872}” portion of the line is the CLSID of the Add-In. Just remembering the first 3 or 4 characters is enough for what you need to do in the subsequent steps.
The other way to find out the CLSID is to look it up in the registry. First, you need to know what to look up. You can use the ProgID of your Add-In. This is determined by the name of your project and the name of the class that supports the Add-In interface. You can see these in the Properties window inside Visual Basic. In this case the ProgID of the Add-In will be “AddInSample.clsSampleAddIn”.
Run RegEdit and look in the HKEY_CLASSES_ROOT section for the ProgID of your Add-In. This is shown below for the sample Add-In.
Once you’ve found the ProgID for the Add-In, expand the key in the registry and then expand the Clsid key and select “Clsid”. In the right-hand portion of the Registry Editor you’ll see the CLSID of your Add-in.
- Now using the Registry Editor, find the HKEY_CLASSES_ROOT\CLSID section of the registry. Within this key, find the CLSID for your Add-In. The picture below shows this key selected in the browser and expanded so you can see its subkeys. You can verify that you have the correct registry key by checking on the right-hand side of the Registry Editor to see if the ProgID matches the one for your Add-In.
- Right-click on the CLSID key of your Add-In and choose Export, as shown below. Specify a name and save the .reg file.
- Copy the Add-In to the 64-bit system by copying the EXE, the reg file you just created in the previous step, and any other files your Add-in might require. The SimpleAddIn sample doesn’t need anything except these two files but your Add-In may need some other files.
- Edit the .reg file so that it contains the correct path for your Add-In as it exists on the 64-bit system. You’ll need to edit one line in the .reg file to correct the path. The edited portion is highlighted below. Notice how the backslashes of the actual path are replaced with double back slashes.
[HKEY_CLASSES_ROOT\CLSID\{DB59D9A7-…-F93E8866E872}\LocalServer32]
@="C:\\Users\\ekins\\Documents\\AddInSample.exe" - Run the .reg file to register your Add-In. When you run Inventor, your Add-In should be running and work. If it isn’t working, check the Add-In Manager to see if your Add-In is in the list. If it is in the list but isn’t listed as being loaded, then the Add-In is likely failing in the Activate method. Make sure you removed the icons as instructed above and double-check that you’re not trying to access something that’s not available on the 64-bit machine.
If your Add-In doesn’t show up at all in the Add-In Manager then go through the directions above and double-check that you didn’t leave out anything. For your Add-In to not show up at all indicates that it’s not being registered correctly.
Converting a Visual Basic 6 Add-In to 64-Bit
Visual Basic 6 is only capable of creating 32-bit applications. To convert an existing project to a 64-bit application will require porting the application to VB.Net, which does support the creation of a 64-bit application. VB.Net has a VB 6 conversion tool but I would suggest that you NOT use it. Instead, I would use the Add-In Wizard that’s delivered as part of Inventor’s SDK to create a new Add-In and copy the code manually from VB 6 into the VB.Net project. There are too many differences between VB 6 and VB.Net and my experience is that cleaning up the resulting code from the conversion is harder than copying over smaller portions of code at a time an manually converting it.
You’ll also need to recreate your dialogs. The dialogs are much more powerful in VB.Net so this lets you take advantage of those new features. The basics of converting your code is covered in this post: Converting VBA Auto Macros to an Add-In.
September 23, 2009
July 28, 2009
July 24, 2009
July 20, 2009
July 14, 2009
Working with STL and OBJ Files
This posting isn’t about how to use the API but is an example of what can be done with the API and hopefully is useful to some of you. A big reason I’m posting it here is that I continue to get requests for the program and this will provide a better way to distribute and update it than the newsgroup.
The program came about after I visited a university a couple of years ago that is using Inventor as part of their engineering program. In one of their classes the students need to create an Inventor model to fit around a model that’s defined by an OBJ file. (OBJ and STL files are formats that define a model using a mesh of triangles.) It was difficult for them to use this data in Inventor and it seemed to me like something could be done to improve the process and it became a pet project of mine.
The Facet Enabler add-in became the result. It’s an add-in that uses client graphics and client features, plus a lot of code of my own. It allows you to read in an OBJ or STL file and see it in Inventor. What you see is just client graphics which means it’s only for display and doesn’t affect the model and can’t be used for other operations like interference checking, measure, etc. To be able to make use of the mesh data for modeling the add-in supports a command that lets you cut a section through the client graphics, which creates a sketch that can then be cleaned up and used as input for standard Inventor features.
The add-in adds two commands to Inventor. The first is added to the part environment. Its icon is the yellow pyramid as shown below (the second to the last command in the panel bar). If using the ribbon interface it is in the Add-Ins panel of the Part ribbon. When you read in the OBJ or STL data a new icon is created in the browser to represent the data. There are also several options to control how it is displayed that are accessed from the context menu, as shown below. (The “Smooth Shading” option is only available if that information existed in the OBJ file. It’s never available for STL data.)
In the sketch environment there’s one new button that’s added. It looks like a sectioned pyramid and is the last command in the panel menu below. It will create sketch geometry that represents a section cut through the faceted model as shown below. You can use the sketch geometry for standard Inventor modeling.
To install the program just download the zip file and run the install program it contains. It will run with Inventor 2009 and later.
Facet Enabler Install Download
Please let me know if you find any problems, have suggestions to improve the program, or want to be notified if there are updates. I’ll also update this blog post when I update the program.
Revisions
July 14, 2009 – Initial Post
July 23, 2009 – Posted version 1.5 which contains a fix to correctly handle line continuation characters in OBJ files.
July 01, 2009
Introduction to Attributes
This is the first of at least two posts on attributes. This first one will cover the basics and subsequent postings will go into some more advanced aspects. Most programs your write will likely only need the information covered in this post.
The attribute functionality of Inventor is something that’s only available through the API; it doesn’t have a user-interface. The basic concept of attributes is very simple; it’s the ability to associate information with Inventor entities. Where it get’s a little more complicated is in understanding when this functionality might apply to your programs and how you can take advantage of it.
First, let’s look at the API for attributes. Every object that supports attributes has the AttributeSets property from which you can access the attributes associated with that particular object. Below is the object model for attributes.
The “Inventor Entity” is any object that supports the AttributeSets property. The AttributesSets object returned by this property is an object collection that lets you access all of the AttributeSet objects associated with the object, and it also lets you create new AttributeSet objects. An AttributeSet is exactly what the name implies; a set of attributes. They provide a way of grouping the attributes associated with an object. Typically, each application that adds an attribute to an object will create their own attribute set so that their attributes aren’t mixed with another application’s attributes.
Creating an Attribute
An AttributeSet object is also a collection object and provides access to the Attribute objects it contains and provides the ability to create new attributes. Below is an example VBA macro that demonstrates this by creating a new attribute set on a selected entity and then adds an attribute to that set.
Public Sub CreateAttribute()
' Get the active document. It can be any type of document.
Dim doc As Document
Set doc = ThisApplication.ActiveDocument
' Get the selected entity.
Dim entity As Object
On Error Resume Next
Set entity = doc.SelectSet.Item(1)
If Err Then
MsgBox "You must select an entity."
Exit Sub
End If
' Get the AttributeSets object from the selected entity.
Dim attribSets As AttributeSets
Set attribSets = entity.AttributeSets
If Err Then
MsgBox "You must select an entity that supports attributes."
Exit Sub
End If
On Error GoTo 0
' Create an attribute set.
Dim attribSet As AttributeSet
Set attribSet = attribSets.Add("SampleSet")
' Create an attribute on the set.
Dim attrib As Inventor.Attribute
Set attrib = attribSet.Add("SampleAttribute", _
kStringType, "A Test")
End Sub
The first portion of the program gets the entity that is currently selected within the active document. Notice that the variable “entity” is declared as Object, indicating that any type of object can be handled. The error handling is used to catch the case where no entity has been selected.
The next section of the program gets the AttributeSets object from the selected entity. Since the program allows you to select anything, the error handling is used to catch the case where the selected object doesn’t support the AttributeSets property.
Finally, we have an AttributeSets object that was obtained from the selected entity. The next section creates an AttributeSet object using the Add method of the AttributeSets object. It supplies the name to use for the AttributeSet. The name must be unique with respect to the other AttributeSet objects associated with that particular AttributeSets object. Typically you would append the set name with your company or application name to make it unique, i.e. “modmachineSampleTest”.
The final section of the program creates an attribute within the attribute set. The creation of the attribute takes three arguments; name, type, and value. The name must be unique with respect to the other attributes within this attribute set. Since it’s likely you’re the only one adding attributes to your set this is easily managed by you. Attributes can be one of four different types; Double, Integer, String, or array of Bytes. In the example above it creates a String attribute with the value of “A Test”.
Getting an Existing Attribute From an Entity
Now that you’ve seen how to create an attribute on an entity, how do you get that attribute back at a later time? There are two ways of accessing attributes. The first uses the objects we’ve already looked at; AttributeSets and AttributeSet. The sample code below illustrates getting the attribute that was just created.
Public Sub GetAttribute()
' Get the active document. It can be any type of document.
Dim doc As Document
Set doc = ThisApplication.ActiveDocument
' Get the selected entity.
Dim entity As Object
On Error Resume Next
Set entity = doc.SelectSet.Item(1)
If Err Then
MsgBox "You must select an entity."
Exit Sub
End If
' Get the AttributeSets object from the selected entity.
Dim attribSets As AttributeSets
Set attribSets = entity.AttributeSets
If Err Then
MsgBox "You must select an entity that supports attributes."
Exit Sub
End If
On Error GoTo 0
' Check to see if it has the "SampleSet" attribute set.
If attribSets.NameIsUsed("SampleSet") Then
' Get the attribute set.
Dim attribSet As AttributeSet
Set attribSet = attribSets.Item("SampleSet")
' Get the attribute on the set.
Dim attrib As Inventor.Attribute
Set attrib = attribSet.Item("SampleAttribute")
MsgBox "Attribute " & attrib.name & " = " & attrib.Value
Else
MsgBox "The entity does not have the expected attribute set."
End If
End Sub
Most of the code in the sample above is the same as the previous sample. However, once it has the AttributeSets object from the selected entity it uses the NameIsUsed property of the AttributeSets object to see if there is an attribute set named “SampleSet”. If there is then it gets the attribute named “SampleAttribute”. Finally it displays the name and value of that attribute.
The approach demonstrated above illustrates how you can get an attribute from an known entity. The problem with this approach is that in many cases you don’t have a reference to the entity the attribute is attached to. For example, you might have attached an attribute to a face so you can use the attribute at a later time to find that face again. Using the technique shown above you would need to iterate over every face in the model until you found the one that had the “SampleSet” attribute set. Not a very efficient way to find the attribute. Another approach of getting attributes is discussed below.
Getting an Existing Attribute Using the Attribute Manager
The other way to find existing attributes is to use the AttributeManager object. This is an object you obtain using the AttributeManager property of the Document object. The most common use of the attribute manager is to query for attributes that exist in the document. For example, the code below will find all entities that have an attribute set called “SampleSet”.
Public Sub GetAttributeUsingManager()
' Get the active document. It can be any type of document.
Dim doc As Document
Set doc = ThisApplication.ActiveDocument
' Get the attribute manager.
Dim attribMgr As AttributeManager
Set attribMgr = doc.AttributeManager
' Find all attribute sets named "SampleSet".
Dim foundEntities As ObjectCollection
Set foundEntities = attribMgr.FindObjects("SampleSet")
MsgBox "Found " & foundEntities.Count & " entities."
End Sub
You can see this is much easier, and faster, than looking through all of the entities to see if they have a particular attribute set.
There are three different Find methods to choose from and you’ll choose one over the other depending on which type of object will be the most convenient for you to use in your program. The three find methods are FindAttributes, FindAttributeSets, and FindObjects. All three of them take the same input arguments and do the same type of search with the only difference being what they return. The FindAttributes method returns a list of Attribute objects as an AttributesEnumerator object. The FindAttributeSets method returns a list of AttributeSet objects as an AttributeSetsEnumerator object. The FindObjects returns a list of entities as an ObjectCollection object.
The three Find methods have three arguments. The first is the name of the attribute set, the second is the name of the attribute, and the third is the value of the attribute. You can use wild cards when searching. For example if I had added the following attribute sets to several different entities, SampleSet1, SampleSet2, SampleSet3, and SampleSet4, the following query would find and return all four attribute sets. Notice the asterisk wild card at the end of “SampleSet”
' Find all attribute sets named "SampleSet".
Dim foundSets As AttributeSetsEnumerator
Set foundSets = attribMgr.FindAttributeSets("SampleSet*")
Dim foundSets As AttributeSetsEnumerator
Set foundSets = attribMgr.FindAttributeSets("SampleSet*")
The following query will find all attribute sets named “SampleSet” that contain an attribute named “TableType”.
' Find all attribute sets named "SampleSet".
Dim foundSets As AttributeSetsEnumerator
Set foundSets = attribMgr.FindAttributeSets("SampleSet", _
Dim foundSets As AttributeSetsEnumerator
Set foundSets = attribMgr.FindAttributeSets("SampleSet", _
"TableType")
This last one find all attribute sets that have an attribute whose value is “ACME Fastener”.
' Find all attribute sets named "SampleSet".
Dim foundSets As AttributeSetsEnumerator
Set foundSets = attribMgr.FindAttributeSets("*", "*", _
Dim foundSets As AttributeSetsEnumerator
Set foundSets = attribMgr.FindAttributeSets("*", "*", _
"ACME Fastener")
As discussed above, the various find methods return different types of objects. Frequently you may have a reference to one type of object but also need the associated objects. We’ve already seen how how you can walk down the object model from an entity to get an associated AttributeSet object and from the AttributeSet object to get the Attribute objects. You can also walk up the object model. If you start with an Attribute object you can use its Parent property to get the AttributeSet object it is associated with. You can use the Parent property of the AttributeSet object to get the parent AttributeSets object. And finally, you can use the AttributeSets object’s Parent property to get the entity the attribute set is associated with.
Why Use Attributes?
A common question when first learning about attributes is “why/how would you use them?”. Attributes don’t do anything by themselves but only serve as a tool to enable other things. Because of this they are used in many different ways for many unique applications. Here are a some examples that illustrate how attributes can be used. They also demonstrate why you would choose one of the find methods of the AttributeManager object over another.
Probably the most common use of attributes is for naming an entity so you can find it later. For example, you might be automating the creation of an assembly and need to find the entities that will be used as input when creating constraints to position the parts in the assembly. One approach is to add an attribute set to the entity so you can use one of the AttributeManager find method find it later. In this case it’s the entity that’s of interest and the attribute is just serving as the mechanism to find the entity and using the FindObjects method makes sense because it directly returns the object so you can easily use it to create the constraint.
Another common example of the use of attributes is adding additional information to an entity that’s important for your application. For example you might write a program to create a custom table in a drawing. In this case each row of the table represents something unique to your application is not something that Inventor is aware of. You can use the API to create a custom table with the data you want to display but you can also add an attribute set to the custom table that contains additional information that will be useful to you to understand where the data in the table came from so you can easily update it. In this case it’s probably the AttributeSets object that’s the most interesting since it gives you easy access to the attributes to allow you to query them to determine the table information. Using the FindAttributeSets method makes more sense in this case.
Here’s an example where Inventor takes advantage of attributes. I talked this in a previous post, http://modthemachine.typepad.com/my_weblog/2009/04/controlling-layers-in-your-flat-pattern-export.html. In this example, you add attributes to the edges of a flat pattern and the translator will use the attributes to determine which layer to create the corresponding geometry on.
Another example is face colors. You can right-click on a face in a part and select the Properties command to change the color of that face. Internally, Inventor remembers the color you selected by adding an attribute to that face that has the name of the color.
Subscribe