Mod the Machine

Accessing iProperties

I was told that it could be useful to provide a list of all the property names used for iProperties - for reference, I assume.

Actually, you can get this list with a simple VBA code 😀

Sub GetPropertySets()
  Dim doc As Document
  Set doc = ThisApplication.ActiveDocument
  
  Dim ps As PropertySet
  For Each ps In doc.PropertySets
    Debug.Print ps.Name + " / " + ps.InternalName
    Dim p As Property
    For Each p In ps
      Debug.Print "  " + p.Name + " /" + Str(p.PropId)
    Next
  Next
End Sub

Here is the result:

Inventor Summary Information / {F29F85E0-4FF9-1068-AB91-08002B27B3D9}
  Title / 2
  Subject / 3
  Author / 4
  Keywords / 5
  Comments / 6
  Last Saved By / 8
  Revision Number / 9
  Thumbnail / 17
Inventor Document Summary Information / {D5CDD502-2E9C-101B-9397-08002B2CF9AE}
  Category / 2
  Manager / 14
  Company / 15
Design Tracking Properties / {32853F0F-3444-11D1-9E93-0060B03C1CA6}
  Creation Time / 4
  Part Number / 5
  Project / 7
  Cost Center / 9
  Checked By / 10
  Date Checked / 11
  Engr Approved By / 12
  Engr Date Approved / 13
  User Status / 17
  Material / 20
  Part Property Revision Id / 21
  Catalog Web Link / 23
  Part Icon / 28
  Description / 29
  Vendor / 30
  Document SubType / 31
  Document SubType Name / 32
  Proxy Refresh Date / 33
  Mfg Approved By / 34
  Mfg Date Approved / 35
  Cost / 36
  Standard / 37
  Design Status / 40
  Designer / 41
  Engineer / 42
  Authority / 43
  Parameterized Template / 44
  Template Row / 45
  External Property Revision Id / 46
  Standard Revision / 47
  Manufacturer / 48
  Standards Organization / 49
  Language / 50
  Defer Updates / 51
  Size Designation / 52
  Categories / 56
  Stock Number / 55
  Weld Material / 57
  Mass / 58
  SurfaceArea / 59
  Volume / 60
  Density / 61
  Valid MassProps / 62
  Flat Pattern Width / 63
  Flat Pattern Length / 64
  Flat Pattern Area / 65
  Sheet Metal Rule / 66
  Last Updated With / 67
  Sheet Metal Width / 68
  Sheet Metal Length / 69
  Sheet Metal Area / 70
  Material Identifier / 71
  Appearance / 72
  Flat Pattern Defer Update / 73
Inventor User Defined Properties / {D5CDD505-2E9C-101B-9397-08002B2CF9AE}

 

Add-In with event example to replace auto-run macros in 2014

Inventor 2014 no longer supports VBA auto-run macros. Here is an excerpt from the Inventor API help file:

Autodesk Inventor 2014 removes support for VBA auto-run macros that are embedded in Autodesk Inventor documents. The VBA macros are AutoOpen, AutoNew, AutoSave, AutoClose, and AutoEdit. They can severely impact Autodesk Inventor performance, and pose a possible security risk. The suggested alternative to auto macros is an add-in. Add-ins don't have the performance and security issues of auto macros and provide much better source control.

If you are using VBA auto-run Macros you will need to start using events to get the same functionality. In one case the AutoSave macro was being used to add the time and day to custom iProperties. This stopped working in Inventor 2014. To get the behavior back an Add-In with an OnSaveDocument event needed to be used. Here is the VB.NET (VS 2010) project that creates an Add-In that that can be used to replace the behavior of the AutoSave VBA macro.

Download AddIn_With_Saved_Event 

There are instructions for creating an Add-In in the API help file. 

.

Here is the event callback:

Private Sub m_ApplicationEvents_OnSaveDocument _

      (ByVal DocumentObject As Inventor._Document,

  ByVal BeforeOrAfter As Inventor.EventTimingEnum,

           ByVal Context As Inventor.NameValueMap,

  ByRef HandlingCode As Inventor.HandlingCodeEnum)

 

    If BeforeOrAfter = EventTimingEnum.kBefore Then

        Try

            'Ensure active document is a Drawing

            If m_inventorApplication.

                           ActiveDocumentType = _

       DocumentTypeEnum.kDrawingDocumentObject Then

 

                'Get the custom iProperties

                Dim oPropSet As PropertySet = _

m_inventorApplication.ActiveDocument.PropertySets _

          ("{D5CDD505-2E9C-101B-9397-08002B2CF9AE}")

 

                Dim bDateAdded As Boolean = False

                Dim bTimeAdded As Boolean = False

 

                Dim prop As Inventor.Property

                For Each prop In oPropSet

                    If prop.Name = "SysDate" Then

                        prop.Value = _

                     Format(Date.Now, "MMM-d-yy")

 

                        bDateAdded = True

                    End If

 

                    If prop.Name = "SysTime" Then

                        prop.Value = _

                  Format(Date.Now, "hh:mm:ss tt")

 

                        bTimeAdded = True

                    End If

                Next

 

                ' If the drawing does not have the

                ' SysDate custom property

                If bDateAdded = False Then

                    oPropSet.Add(Format(Date.Now, _

                            "MMM-d-yy"), "SysDate")

                End If

 

                ' If the drawing does not have the

                ' SysTime custom property

                If bTimeAdded = False Then

                    oPropSet.Add(Format(Date.Now, _

                         "hh:mm:ss tt"), "SysTime")

                End If

 

            End If ' if document is a drawing

        Catch ex As Exception

            MsgBox(ex.ToString())

 

        End Try

    End If 'if before save

 

End Sub

 

-Wayne

Accessing Thumbnail Images

I’ve had a few recent posts that have talked briefly about using thumbnail images (Document Thumbnails and Button Icons, Parts List with Thumbnail Image, and Accessing iProperties).  If you need to get a thumbnail image from an Inventor document there are several possibilities.  I want to briefly cover those here.

Thumbnail as an iProperty
The thumbnail is stored as an iProperty within an Inventor document.  One way to access the thumbnail is as an iProperty.  The following VBA code accesses the thumbnail as an iProperty and writes it as a bmp file to disk.  (This code won’t work on a 64-bit Inventor because of the issues discussed in this post.)

Public Sub WriteThumbnail()
    ' Get the currently active document.
    Dim doc As Document
    Set doc = ThisApplication.ActiveDocument

    ' Get the Summary Information property set.
    Dim summaryInfo As PropertySet
    Set summaryInfo = doc.PropertySets.Item( _
                                     "Inventor Summary Information")

    ' Get the thumbnail property.  When using VBA, this will
    ' only work with 32-bit Inventor.
    Dim thumbProp As Property
    Set thumbProp = summaryInfo.Item("Thumbnail")

    ' Get the thumbnail image.
    Dim thumbnail As IPictureDisp
    Set thumbnail = thumbProp.Value

    ' Check that an image was returned.  It's possible for a
    ' file to not have a thumbnail.
    If Not thumbnail Is Nothing Then
        ' Write the thumbnail to disk.
        Call SavePicture(thumbnail, "C:\Temp\Thumb.bmp")
    Else
        MsgBox "The active document doesn't have a thumbnail."
    End If
End Sub

Because Apprentice provides access to iProperties, you can use it instead of Inventor to access the thumbnail.  Below is some VB.Net code that uses Apprentice to read a thumbnail from an Inventor document and display it within a picture box.

To use the code below, create a new “Windows Form Application”.  On the form add a button (Button1) and a picture box (PictureBox1).  Set the SizeMode property of the picture box to StretchImage.  My dialog is shown below.

You’ll also need to add references to the following components using the .Net tab of the Add Reference dialog:

Autodesk.Inventor.Interop
Microsoft.VisualBasic.Compatibility
stdole

Here’s my implementation for the form and the button click sub.

Imports Inventor
Imports Microsoft.VisualBasic

Public Class Form1 
   Private Sub Button1_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) Handles Button1.Click 
      ' Create an instance of Apprentice. 
      Dim apprentice As New ApprenticeServerComponent

      ' Open a document. 
      Dim doc As ApprenticeServerDocument 
      doc = apprentice.Open("C:\Temp\Part1.ipt") 

      ' Get the Summary Information property set. 
      Dim summaryInfo As PropertySet 
      summaryInfo = doc.PropertySets.Item( _
                                    "Inventor Summary Information") 

      ' Get the thumbnail property. 
      Dim thumbProp As Inventor.Property 
      thumbProp = summaryInfo.Item("Thumbnail") 

      ' Get the thumbnail image. 
      Dim thumbnail As stdole.IPictureDisp 
      thumbnail = thumbProp.Value 

      ' Convert the IPictureDisp object to an Image. 
      Dim img As Image = _
                    Compatibility.VB6.IPictureDispToImage(thumbnail)

      ' Display the image in the picture box. 
      PictureBox1.Image = img 
   End Sub
End Class

And here’s the result.

Document.Thumbnail Property
There’s another way you can get the thumbnail that’s simpler than going through the iProperty objects.  Both the Document and ApprenticeServerDocument objects  support the Thumbnail property.  Here’s a modified version of the program above that uses the Thumbnail property.

Imports Inventor
Imports Microsoft.VisualBasic

Public Class Form1 
   Private Sub Button1_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) Handles Button1.Click 
      ' Create an instance of Apprentice. 
      Dim apprentice As New ApprenticeServerComponent

      ' Open a document. 
      Dim doc As ApprenticeServerDocument 
      doc = apprentice.Open("C:\Temp\Part1.ipt")  

      ' Get the thumbnail image. 
      Dim thumbnail As stdole.IPictureDisp 
      thumbnail = doc.Thumbnail

      ' Convert the IPictureDisp object to an Image. 
      Dim img As Image = _
                    Compatibility.VB6.IPictureDispToImage(thumbnail)

      ' Display the image in the picture box. 
      PictureBox1.Image = img 
   End Sub
End Class

A big difference between using the Document.Thumbnail property and accessing the thumbnail as an iProperty is that the Document.Thumbnail property is read-only while the iProperty is writable.  This means you can push any image you would like into the iProperty to be used as the thumbnail for that document.  However, this is only supported in Inventor and setting the value of the thumbnail iProperty will fail when using Apprentice.

ThumbnailView Component
There’s one other way of accessing a thumbnail.  Because iProperties are stored using some Microsoft standards, it’s possible to use Windows functionality to directly access the thumbnail without using Inventor or Apprentice.  It requires some more advanced programming to do it this way, so to make it easier there’s a  component delivered as part of the Inventor SDK that you can use rather than write the code yourself.  The source code is also provided to serve as a sample for those that want to include this functionality within their applications.

To use this component you need to first install the DeveloperTools.msi package.  This is in the Inventor SDK directory (C:\Program Files\Autodesk\Inventor 2011\SDK on WinNT and C:\Users\Public\Documents\Autodesk\Inventor 2011\SDK on Vista or Win7).  Installing this will create an SDK\DeveloperTools\Tools\ThumbnailView directory that contains the component, its source code, and some samples demonstrating its use.

To use the component, go into the Bin directory and run the Register.bat file to register the component.  In your project where you’ll be using the component you’ll need to add a reference to it.  I typically use the Browse option and browse to the InventorThumbnailView.dll file.  Here’s a version of the previous program that uses this component to get the thumbnail.

Imports Microsoft.VisualBasic

Public Class Form1 
   Private Sub Button1_Click(ByVal sender As System.Object, _
                ByVal e As System.EventArgs) Handles Button1.Click 
      ' Create an instance of the ThumbnailProvider component.
      Dim thumbView As New InventorThumbnailViewLib.ThumbnailProvider

      ' Get the thumbnail image. 
      Dim thumbnail As stdole.IPictureDisp 
      thumbnail = thumbView.GetThumbnail("C:\Temp\Part1.ipt")

      ' Convert the IPictureDisp object to an Image. 
      Dim img As Image = _
                    Compatibility.VB6.IPictureDispToImage(thumbnail)

      ' Display the image in the picture box. 
      PictureBox1.Image = img 
   End Sub
End Class

One thing important to notice is that there’s no longer a reference to the Inventor component required since this isn’t using the Inventor API.

Inventor 2011 and ThumbnailView
The ThumbnailView component has been provided as a sample for several releases of Inventor.  However, an issue was discovered soon after Inventor 2011 was shipped where it was found the component doesn’t work with Inventor 2011 files.  In Inventor 2011 a change was made to how the thumbnail image is stored within the iProperty value.  Previously to Inventor 2011 it was stored as a bmp image.  In Inventor 2011 it’s now saved as a png image.  All of the other functionality that deals with the thumbnail, iProperties and the Document.Thumbnail property, were updated to account for this change.  However, the ThumbnailView utility slipped through the cracks and was not updated.  You can access an updated version of the component here that works with Inventor 2011 and previous files.

Creating Custom Property Sets and iProperties

In all previous iProperty related posts I’ve only talked about working with the four public property sets; Design Tracking, Summary Info, Document Summary Info, and User Defined.  The first three of these contain a fixed number of properties while the user defined allows you to add and delete your own properties.  This mirrors the iProperty functionality that’s available through Inventor’s user-interface.

Using the API it’s possible to create new property sets in addition to these standard four.  A property set created using the API is not visible through the user-interface.  For example, it does not automatically create a new tab in the iProperty dialog.  It is only accessible through the API.  The code below creates a new property set named “MyStuff” and a property named “Favorite Fruit”.

Public Sub CreatePropertySet()
    ' Get the active document.
    Dim doc As Document
    Set doc = ThisApplication.ActiveDocument

    ' Create a new property set.
    Dim customSet As PropertySet
    Set customSet = doc.PropertySets.Add("My Stuff")

    ' Add a property.
    Call customSet.Add("Banana", "Favorite Fruit")
End Sub

Here’s some sample code that accesses and reads the value of the property created above.

Public Sub ReadProperty()
    ' Get the active document.
    Dim doc As Document
    Set doc = ThisApplication.ActiveDocument

    ' Get the custom property set.
    Dim customSet As PropertySet
    Set customSet = doc.PropertySets.Item("My Stuff")

    ' Get the value of the "Favorite Fruit" property.
    Dim fruit As String
    fruit = customSet.Item("Favorite Fruit").value
    MsgBox "The favorite fruit is: " & fruit
End Sub

Hopefully you can see that working with these custom property sets is not any different than working with the standard property sets.  It’s likely that you won’t ever  need for this capability but sometimes it can come in handy.  The primary use is when you need to store additional data with a file.  iProperties especially make sense when you want to be able to access this information from Apprentice.  An example of where Inventor uses this functionality is Content Center.  Content Center adds an new property set to the parts it creates and uses the property set to store information about the part.

A useful tool when working with iProperties is a sample program that’s delivered with the Inventor SDK.  Assuming you’ve installed the developer tools using the DeveloperTools.msi in the SDK directory, you’ll find the following directory:

SDK\DeveloperTools\Samples\VB\Standalone Applications\ApprenticeServer\Properties

It’s an old VB6 sample, but you can use the EXE without having VB6.  When you run the EXE, the dialog below is displayed.  You use the button at the top to browse to any Inventor file.  The property sets and properties are then displayed in the dialog and you can double-click on most properties to edit them.  I use tool anytime I want to know about all of the iProperties in a document.

iProperties and Dates

 
The previous post on working with custom iProperties shows how to create iProperties of various types, including dates.  However, dates have one unique behavior, as shown below.  There is a check box next to each date property, (circled in the picture below), that the user can check or uncheck to indicate if they want to set a date or not.

A date iProperty will always have a value, but there is one date that is considered the zero date.  If you set the iProperty value to this date it will have the side-effect of removing the check from the box.  The date is Jan. 1, 1601.  The code below demonstrates creating two new custom iProperties.  One will be set to the zero date and the other will be set to the current date.

Public Sub DateProperties()
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument

    ' Get the custom property set.
    Dim customPropSet As PropertySet
    Set customPropSet = partDoc.PropertySets.Item( _
                                "Inventor User Defined Properties")

    ' Create the properties.
    Dim dateValue As Date
    dateValue = #1/1/1601#
    Dim sample1 As Property
    Set sample1 = customPropSet.Add(dateValue, "Zero Date")

    dateValue = Now
    Dim sample2 As Property
    Set sample2 = customPropSet.Add(dateValue, "Now Date")
End Sub

Here’s the result after running the program.  Notice that the check box for the zero date property is unchecked.

This is also important to understand if you ever need to read the value of a date property.  In the example above, the date for the Zero Date iProperty will be Jan. 1, 1601, but you should handle this date as a special case and treat it as though the date hasn’t been set.

iProperty Expressions

In the iProperties dialog, Inventor allows you to create expressions for the values of iProperties.  Using an expression you can combine the values of other iProperties into a single iProperty value.  (By using the functionality described in a previous post to create an iProperty for a parameter, you can also use parameter values in an expression.)  To create an expression just enter an “=” sign as the first character of the iProperty value.  Inventor will now treat this as an expression.  An expression can consist of any text and can reference any existing iProperties by specifying their names in brackets, as shown below.  The expression in this example uses the iProperty named “Part Number” and two custom iProperties named “Length” and “Height” that were created by exporting parameters.

Once you’ve finished entering the expression and press return, the expression is evaluated and the resulting value is displayed, as shown below. 

The symbol to the right of the field indicates that the property is defined using an expression.  To edit the expression, rather than the value, right-click in the iProperty field and select the Edit Expression command from the context menu, as shown below.

To use expressions through the API you use the Expression property of the Property object.  This is demonstrated below.  The Expression property is the equivalent of editing the expression in the iProperties dialog.  When setting the value of the Expression property you need to follow the same rules as when creating an expression in the iProperties dialog.  The Value property of the Property object will always return the evaluated result.  Setting the value through the Value property will remove the expression associated with the property or you can set the value of the expression to an empty string (“”).

Public Sub TestExpression()
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument

    ' Get the Design Tracking property set.
    Dim designTrackPropSet As PropertySet
    Set designTrackPropSet = partDoc.PropertySets.Item( _
                                     "Design Tracking Properties")

    ' Get the Description property.
    Dim descProp As Property
    Set descProp = designTrackPropSet.Item("Description")

    ' Add an expression to the property.
    descProp.Expression = _
                     "=<Part Number> size is <Length> x <Height>"
End Sub

The program below removes the expression from the property but maintains the property’s current value.  It does this by setting the value of the property to its current value.  This would at first seem like it wouldn’t do anything, but in the case where the property is defined using an expression, setting the value of the property removes the expression.  It’s just that in this case the value we’re setting it to happens to be the current displayed value.

Public Sub TestExpression()
    Dim partDoc As PartDocument
    Set partDoc = ThisApplication.ActiveDocument

    ' Get the Design Tracking property set.
    Dim designTrackPropSet As PropertySet
    Set designTrackPropSet = partDoc.PropertySets.Item( _
                                     "Design Tracking Properties")

    ' Get the Description property.
    Dim descProp As Property
    Set descProp = designTrackPropSet.Item("Description")

    ' Set the value of the property to it’s current value.
    ' This has the side-effect of removing an associated expression.

    descProp.Value = descProp.Value
End Sub

Parameters as iProperties

The next few posts I’ll be making are intended to complete my coverage of topics related to iProperties.  I’ve made several recent posts that I believe cover the majority of the API functionality that will enable you to write most programs that use iProperties.  However, there are a few odds and ends that I haven’t covered.  Here’s the first of these last set of posts on iProperties.

In the Parameters dialog you can check the Export Parameter box for a parameter, as shown circled below.  This is useful because there are quite a few areas in Inventor that provide access to property values, (text in drawings, BOM, etc.), and by exporting a parameter as a property it extends the use of the existing functionality to also be able to use parameters.

This causes a custom iProperty to be created that contains the value of that parameter.  This is a one-way association.  Changing the parameter will cause the iProperty to update, but changing the value of the iProperty will not cause the parameter to update.  The iProperty is just a reflection of the parameter and will be updated whenever the parameter value changes.

If the Export Parameter box is checked, then you can also access the Custom Property Format… command through the context menu, as shown below.

This displays the dialog shown below where you can control the format of the iProperty that’s created for this parameter.

This all results in the iProperty shown below.  The name of the iProperty is the same as the parameter.  If an iProperty of that name already exists, it’s value will be overwritten to the value of the parameter.  You can edit and even delete the iProperty, but Inventor will overwrite the edited value or re-create the iProperty whenever the parameter value changes.

From the API you can also set the “Export Parameter” box for a parameter.  You do this by using the ExposedAsProperty property of the Parameter object.  With Inventor 2010 and later you can also edit the formatting of the resulting iProperty using the CustomPropertyFormat property of the Parameter object.  This is demonstrated in the code below.

Dim param As Parameter
Set param = partDoc.ComponentDefinition.Parameters.Item("Length")
param.ExposedAsProperty = True

param.CustomPropertyFormat.Precision = kThreeDecimalPlacesPrecision
param.CustomPropertyFormat.ShowTrailingZeros = True
param.CustomPropertyFormat.ShowUnitsString = True
param.CustomPropertyFormat.Units = "in"

iProperties created as the result of an export appear like any other property through the API.  In fact, the iProperty doesn’t know it’s the result of an export.  If you need to find the iProperties that were created through an export you’ll would need to look through the parameters to see if any of them have been exported.

iProperty Performance

Here’s some performance data regarding using Inventor and Apprentice to work with iProperties.  I found this interesting and think it will be useful when architecting your programs so you fully understand the advantages and disadvantages of different approaches.

All of the test results shown below are for processing 1000 unique files.

Test 1 – Open, Edit, Save, Close
This test opened each of the 1000 files, edited the value of two iProperties, saved the document, and closed it.

1. Apprentice – 116 seconds.
2. Inventor (visible document) – 1068 seconds.  This test opened the documents visibly by setting the second argument of the Documents.Open method to True.
3. Inventor (invisible document) – 238 seconds.  This is the same as the test above but opens the documents invisibly by setting the second argument of the Documents.Open method to False.

The biggest difference is between opening the document visibly or invisibly.  When a document is opened invisibly, Inventor is able to optimize the open and not read all of the file.  Opening a file invisibly is similar to the time it takes in Apprentice, as shown by test 2 below.  However, for test 1 Apprentice is still twice as fast.  Two things account for the extra time spent by Inventor; changing the property value and saving the document.  Changing the value of an iProperty in Inventor is transacted, meaning that you can undo the operation.  Transacting has some overhead which accounts for some of the time.  Apprentice doesn’t have any transaction capabilities so it doesn’t have this overhead.  The other big difference is the save.  To save an iProperty change in Inventor you need to save the entire document using Document.Save.  In Apprentice you can save just the iProperty portion of the document using PropertySets.FlushToFile.

Test 2 – Open, Read, Close
This test also operated on all 1000 files by opening a file, reading property values, and closing the document.

1. Apprentice – 92.341 seconds
2. Inventor (invisible document) – 100.374 seconds

These numbers show that there isn’t a lot of difference between invisible Inventor and Apprentice when you don’t do anything that’s transacted and you don’t save the document.  This is particularly important for add-in writers to understand since you can’t use Apprentice within an add-in.

Test 3 – Open, Close
This test uses VB.Net to open and close the same 1000 files.  It opens a file, reads the file into memory, and closes the file.  It is a pure VB.Net program and has nothing to do with Inventor.  I wrote this program to help understand how much of the time is spent on general overhead of reading the file and how much time is spent by Inventor or Apprentice actually doing the work they need to do.  As you can see, most of the time used by Apprentice or Inventor is system overhead of opening and reading the file.  Anytime you have to read or write data to a hard drive, performance will be slow.

1. VB.Net – 77.69 seconds

Summary
If you need to write a utility to manipulate iProperties, using Apprentice will allow you to create the fastest program.  However, if you just need to read iProperty data, opening documents invisibly in Inventor is almost as fast and a good alternative.  Remember that Apprentice cannot be used within an add-in.  If you need to do a lot of iProperty processing (writing and saving) through an add-in it might be worth creating a separate exe that uses apprentice that your add-in uses.  You need to be careful that those documents are not currently open in Inventor.

Gotcha
Here’s something to watch out for when doing any timing tests like those above.  The first time I ran a test it was slow and subsequent runs were significantly faster.  For example, when I first ran test 2 with Inventor it took 100 seconds and then running the same test a second time only took 4 seconds.  Even test 3, which doesn’t have anything to do with Inventor went from 77 seconds for the first run down to 0.338 seconds for subsequent runs.  What’s happening is that Windows is caching data in memory in case the data is used again.  This is great if you are reusing data but I think in most workflows where you’re batch reading and updating iProperties this won’t be the case.  To get the times reported above I rebooted between each test to clear memory and force the data to be read from disk.

iProperties Without Inventor (Apprentice)

Continuing with the iProperty theme of some recent posts I want to talk about the ability to work with iProperties without using Inventor. You can do this using a component known as Apprentice. Apprentice doesn’t have a user-interface but is a component use can only use through programming. Apprentice is installed as part of Inventor and is also installed as part of Inventor View (www.autodesk.com/inventorview).  This means if Inventor or Inventor View is installed on a machine you’ll have access to the Apprentice component and any Apprentice dependent program will work.  The fact that it’s available with Inventor View is interesting since Inventor View is free.

What is Apprentice?
Apprentice is a programming component that provides access to Inventor files.  Using Apprentice you can open Inventor files, query information from them, and in a few cases, edit data.  Apprentice supports a small subset of the functionality that Inventor supports and is primarily read-only with just a few exceptions.  The primary things it provides access to are:

• Geometry of solids and surfaces (B-Rep)
• Assembly structure
• File references
• Bill Of Material
• Printing
• Attributes
• iProperties

You’ll notice that there are a lot of things missing.  Apprentice is designed to be smaller and faster than Inventor and achieves this by providing having less code and operating on smaller portions of a document.  Even things that are exposed in Apprentice will often have limitations that aren’t present in Inventor.  For example, let’s say you have an extrude feature that you’ve added an attribute to in Inventor.  Using Apprentice, you can open that part and you can query for all attributes and get the attribute set associated with the feature.  However when you try and get the feature from the attribute set it’s not available because Apprentice doesn’t support features.  Apprentice is good at what it does but does have limitations you need to be aware of before attempting to use it in a project.

Using Apprentice
Apprentice uses much of the same code and components as Inventor.  Because of this there are conflicts if you try running both of them within the same process.  Remember that Apprentice always runs within the process of another program.

This means:

• You can’t use Apprentice with Inventor’s VBA.
• You can’t use Apprentice in an Add-In.

Using VBA within another application, for example Excel, is ok since Apprentice will be running within the Excel process and not Inventor’s process.  Another common use of Apprentice is within standalone exe programs where Apprentice will be running within the exe process.  The example that part of this post is a standalone exe.

Another limitation of Apprentice is that it can’t migrate files.  Migration occurs when you open a file that is older than the current version of Inventor.  For example, if I have an Inventor 2009 file on disk and open it with Inventor 2010 the data is migrated to the current version of Inventor.  Inventor is smart and only migrates what’s necessary based on what you’re currently doing with the file.  However, if you save the file, the entire file must be migrated to the current version before it is saved.  Apprentice can open and query older files but nothing can be changed and saved because that would require migration.  You can use the NeedsMigrating property to determine if a file can be edited and saved.  This is demonstrated in the sample at the bottom of this post.

Connecting to Apprentice
Here’s an example of how to use Apprentice within a VB Express Windows forms application.  To enable the use of Apprentice in your program you need to add a reference to the Inventor Object Library.  The Inventor Object Library is used for both Inventor and Apprentice even though Apprentice only supports a small subset of the entire library.  You can add the reference using the Project | Add Reference… command.  In the example below I’ve select the version 14.0.0 (Inventor 2010) interop.

Below is the minimum code needed to load Apprentice.  This declares and creates a new ApprenticeServerComponent object.  The ApprenticeServerComponent object is similar to the Inventor Application object.  It is the top-level object for Apprentice.

Dim apprentice As New Inventor.ApprenticeServerComponent

It’s also common to declare the variable and then create apprentice separately, like shown below.  I do this in the sample program where the variable is declared as a member variable so I can reuse it.

Dim apprentice As Inventor.ApprenticeServerComponent
apprentice = New Inventor.ApprenticeServerComponent

When you create the ApprenticeServerComponent object the Apprentice dll’s are loaded into your process and you can access the apprentice functionality through the properties and methods of the object.

Once you have an instance of the ApprenticeServerComponent, the next step is to open an Inventor document.  You do this using the Open method of the ApprenticeServerComponent object, as shown below.

' Open a file using Apprentice.
Dim apprenticeDoc As Inventor.ApprenticeServerDocument
apprenticeDoc = apprentice.Open(Filename)

Apprentice supports the ApprenticeServerDocument and ApprenticeServerDrawingDocument types.  The ApprenticeServerDocument object can represent all document types.  the ApprenticeServerDrawingDocument can be used to access some drawing specific functionality.

Using iProperties With Apprentice
Once you have the document, accessing iProperties is the same in Apprentice as it is in Inventor.  The example below gets the summary information property set and changes the value of the “Company” property.  The previous posts on using the API with iProperties also apply to Apprentice.

' Get the "Summary Information" property set. 
Dim summaryPropSet As Inventor.PropertySet 
summaryPropSet = apprenticeDoc.PropertySets.Item( _ 
                           "Inventor Document Summary Information") 

' Get the "Company" property. 
Dim companyProp As Inventor.Property 
companyProp = summaryPropSet.Item("Company")

' Change the value of the iProperty. 
companyProp.Value = "Widgets R Us"

Saving Changes With Apprentice
When you use Inventor to change iProperties, you save the changes by saving the document.  In Apprentice there’s a much more efficient way of saving iProperty changes.  Instead of saving the entire document it’s possible to just save the iProperties.  You do this using the FlushToFile method of the PropertySet object, as illustrated below.

' Save the iProperty changes. 
apprenticeDoc.PropertySets.FlushToFile()

Example Program
Here’s an example program written using Visual Basic 2008 Express.  It demonstrates the functionality discussed above.  It’s a simple program that gets all of the part files in a specified directory, changes an iProperty value and saves it.  Even though it’s simple it does demonstrates the functionality needed to access iProperties using Apprentice.  You’ll need to modify it to fit your specific requirements.

Another iProperty Custom Dialog Example

When writing the previous post about a custom dialog for iProperty entry I had forgotten about another example I had put together a couple of years ago.  This is similar but I think is better at demonstrating how useful this concept can be.  In this case there’s a custom dialog that looks like a title block.  This significantly simplifies filling out the title block.  Instead of the user having to search through the iProperties dialog and remember which property corresponds to which field on the title block they just fill out the title block directly.  For this example, one of the fields is also a prompted text entry to demonstrate that you’re not limited to only using iProperties.  This sample doesn’t demonstrate it but it could also use drop-down fields with lists like that shown in the previous post.

When the program is run, this is what the user sees.  It’s a VBA dialog that was created by doing a screen shot of the title block and inserting that as an image on the dialog.  The various text controls were added on top of the image.

One the dialog is filled out and the “Apply” button is pressed it sets the corresponding iProperties and the prompted text and then the title block automatically updates to reflect those changes.  Here’s the result.

Here’s a zip file containing a sample drawing that has the custom iProperties and the prompted text field the sample program expects and it contains a VBA project that contains the source code.  If you want to implement this within your company I would recommend writing this as an add-in rather than VBA, like the previous post demonstrates.