Mod the Machine

Using C# with the Inventor API (Part 1)

My last post contained VB.Net and C# versions of a VBA program from an earlier post.  Converting the VBA program to VB.Net was relatively easy.  The conversion to C# wasn’t as easy.  In this post I want to begin covering many of the issues you’ll run into when converting VBA code to C#.

One question that might come to mind is why would you want to convert from VBA and not just write everything in C# to begin with?  The first reason is that many of the programming samples you’ll find for the Inventor API are written using VBA.  The second reason is that VBA remains the fastest and easiest way to access and use the Inventor API.  Having said that, it does have a lot of other shortcomings so I wouldn’t recommend it for general development, but if you’re not using it for prototyping you’re missing out on a very powerful tool.

To go from VBA to C#, I’ve found the simplest method is to first convert the code to VB.Net.  This is typically fairly easy, particularly if the VBA code was written with going to VB.Net in mind.  For example, all arrays should be 0 based.  In many cases it’s just a copy and paste and Visual Studio will automatically do some syntax conversion.  Some of the manual changes that were required I went over in the previous post.  The next step is to go from VB.Net to C#.  There are some converters that do a pretty good job of automatically converting the VB.Net code to C#.  I found an online converter using Google that worked great.  (For any syntax issues that might still come up, here’s a good comparison of VB.Net and C#.)  Next you’ll need to account for other differences that are typically specific to a COM Automation API, like Inventor’s.  It’s those issues that this series of posts will attempt to cover.

Item Property
C# hides the fact that there’s an Item property on the Inventor collection objects so  you access the contents of the collection as if it was a read-only array, except the first item has an index of 1.

VBA

    Dim body As SurfaceBody 
    Set body = partDef.SurfaceBodies.Item(1)

C#

    SurfaceBody body;
    body = partDef.SurfaceBodies[1];

Comparing Two Objects
Sometimes you need to check if two variables referencing objects are referring to the same object.  Here’s how you do it in VBA and C#

VBA

    ' Get a parameter using two different collections.
    Dim var1 As Parameter
    Set var1 = partDef.Parameters.Item("Length")
    Dim var2 As ModelParameter
    Set var2 = partDef.Parameters.ModelParameters.Item("Length")  

    ' Verify that the variables are referencing the same parameter.
    If var1 Is var2 Then
        MsgBox "The two variables reference the same object."
    End If

C#

  // Get a parameter using two different collections. 
  Parameter var1 = partDef.Parameters["Length"]; 
  ModelParameter var2;
  var2 = partDef.Parameters.ModelParameters["Length"]; 

  // Verify that the variables are referencing the same parameter. 
  if (var1 == var2) 
  { 
    MessageBox.Show("The two variables reference the same object."); 
  }

Checking the Type of an Object
Sometimes it’s useful to be able to check if an object is a certain type.  Both VBA and C# provide an easy way to do this.

VBA

    ' Get the selected object. 
    ' This will fail if nothing is selected.
    Dim selectedObject As Object
    Set selectedObject = _
                   ThisApplication.ActiveDocument.SelectSet.Item(1)

    ' Check that the selected object is a sketch line.
    If TypeOf selectedObject Is SketchLine Then
        MsgBox "Selected object is a sketch line"
    Else
        MsgBox "Something besides a sketch line is selected."
    End If

C#

    // Get the selected object. 
    // This will fail if nothing is selected.
    object selectedObject = invApp.ActiveDocument.SelectSet[1];

    // Check that the selected object is a sketch line.
    if (selectedObject is SketchLine)
        MessageBox.Show("Selected object is a sketch line");
    else
        MessageBox.Show("Something besides a sketch line is
                         selected.");

Iterating Through the Contents of a Collection
Using a For Each loop is the most efficient way to iterate through the contents of a collection.  In some cases it can be much faster than using the collection’s Count and Item properties.

VBA

    ' Iterate over all of the faces in the primary body.
    Dim area As Double
    Dim partFace As Face
    For Each partFace In partDef.SurfaceBodies.Item(1).Faces
        area = area + partFace.Evaluator.area
    Next

    MsgBox "Total surface area: " & area & " cm^2"

C#

    // Iterate over all of the faces in the primary body.
    double area = 0;
    foreach( Face partFace in partDef.SurfaceBodies[1].Faces)
    {
        area += partFace.Evaluator.Area;
    }

    MessageBox.Show("Total surface area: " + area + " cm^2");

Sketch Curve as Line Segments in VB.Net and C#

Here’s the VB.Net and C# versions of the VBA program from previous post.  To go from that VBA program to this VB.Net version was fairly easy.  I just copied and pasted the VBA code into a new VB.Net project.  The primary changes that I had to make were primarily to the array declarations.  Another change, although it wasn’t required, was to change the error handling from the On Error style to Try Catch.  I prefer the Try Catch style of error handling. 

The array declaration change is because in .Net declaring an array isn’t enough to  initialize it.  The VBA version of one of the declarations is here:

        Dim startCoord() As Double

Here’s the .Net version of the same array.

        Dim startCoord() As Double = {}

Here’s the full VB.Net program.  The Inventor Application object is passed in as an argument.  The act of pasting the VBA code into a .Net program automatically removed all of the Set statements because they’re not longer needed in .Net, which is nice.  I also like to enclose arguments to a method within parentheses.  In VBA the parentheses are optional and use have to use the Call statement to have them.  In VB.Net parentheses are required and using a Call statement is optional.  Other than these minor changes, it’s the same code as the original VBA version.

Public Sub CreateSegmentedCurve(ByVal invApp As Inventor.Application)
    ' Check to see that a curved sketch entity is selected.
    Dim entity As SketchEntity
    Try
        entity = invApp.ActiveDocument.SelectSet.Item(1)
    Catch ex As Exception
        MsgBox("A curved sketch entity must be selected.")
        Exit Sub
    End Try 

    If TypeOf entity Is SketchPoint Or _ 
       TypeOf entity Is SketchLine Then
        MsgBox("A curved sketch entity must be selected.")
        Exit Sub
    End If 

    ' Ask for the number of segments to break the curve into.
    Dim prompt As String
    prompt = "Enter the number of segments for the curve."
    Dim segmentCount As Integer
    segmentCount = Val(InputBox(prompt, "Number of Segments", "10"))
    If segmentCount = 0 Then
        MsgBox("Invalid segment count.")
        Exit Sub
    End If

    ' Get the parent sketch.
    Dim sk As Sketch = entity.Parent 

    ' Get the evaluator from the associate geometry.
    Dim curveEval As Curve2dEvaluator = entity.Geometry.Evaluator
    Dim minU As Double
    Dim maxU As Double 
    curveEval.GetParamExtents(minU, maxU) 

    ' Determine if the entity is open or closed (circle,
    ' ellipse, or closed spline)
    Dim curveIsClosed As Boolean = False
    If TypeOf entity Is SketchCircle Or _
       TypeOf entity Is SketchEllipse Or _
       TypeOf entity Is SketchSpline Or _
       TypeOf entity Is SketchOffsetSpline Then
        If TypeOf entity Is SketchSpline Or _
           TypeOf entity Is SketchOffsetSpline Then
            If entity.Closed Then
                curveIsClosed = True
            End If
        Else
            curveIsClosed = True
        End If
    End If

    Dim tg As TransientGeometry = invApp.TransientGeometry 

    ' Determine if start point is at the min or max parameter.
    Dim startPoint As SketchPoint = Nothing
    Dim endPoint As SketchPoint = Nothing
    If Not curveIsClosed Then
        Dim startCoord() As Double = {}
        Dim endCoord() As Double = {} 
        curveEval.GetEndPoints(startCoord, endCoord)
        If entity.StartSketchPoint.Geometry.IsEqualTo( _
          tg.CreatePoint2d(startCoord(0), startCoord(1))) Then
            startPoint = entity.StartSketchPoint
            endPoint = entity.EndSketchPoint
        Else
            endPoint = entity.StartSketchPoint
            startPoint = entity.EndSketchPoint
        End If
    End If 

    ' Get the curve length.
    Dim length As Double 
    curveEval.GetLengthAtParam(minU, maxU, length) 

    ' Determine the length between segments.
    Dim offset As Double
    offset = length / segmentCount 

    ' Start a transaction to wrap the sketch creation as a
    ' single undo operation.
    Dim trans As Transaction = Nothing
    Try
        Dim transMgr As TransactionManager
        transMgr = invApp.TransactionManager
        trans = transMgr.StartTransaction( _
                        invApp.ActiveDocument, "Segment Curve") 

        ' Defer updates on the sketch while the sketch entities
        ' are being created.  This will significantly improve
        ' performance.
        sk.DeferUpdates = True 

        ' Calculate the points and create a sketch
        ' point at each position.
        Dim points() As SketchPoint
        ReDim points(segmentCount)
        Dim currentLength As Double = 0
        For i As Integer = 0 To segmentCount
            Dim currentParam As Double 
            curveEval.GetParamAtLength(minU, currentLength, _ 
                                       currentParam)
            currentLength = currentLength + offset 

            Dim params(0) As Double
            params(0) = currentParam
            Dim coords() As Double = {} 
            curveEval.GetPointAtParam(params, coords) 

            If i = 0 Then
                ' Special case for the first point.
                If Not curveIsClosed Then
                    points(i) = startPoint
                Else
                    points(i) = sk.SketchPoints.Add( _
                           tg.CreatePoint2d(coords(0), coords(1)), _
                           False)
                    endPoint = points(i)
                End If
            ElseIf i = segmentCount Then
                ' Special case for the last point
                points(i) = endPoint
            Else
                points(i) = sk.SketchPoints.Add( _
                           tg.CreatePoint2d(coords(0), coords(1)), _
                           False)
            End If
        Next 

        ' Connect the points with lines.
        For i As Integer = 0 To segmentCount - 1 
            sk.SketchLines.AddByTwoPoints(points(i), points(i + 1))
        Next 

        ' Make the selected entity construction geometry.
        entity.Construction = True 

        ' There's a current problem that when setting the
         ' construction property, the display isn't updated
        ' to reflect this change until something causes the
        ' sketch to recompute.  This performs a change on
        ' the sketch to kick a recompute.
        Dim originalPoint As Point2d
        originalPoint = points(0).Geometry 
        points(0).MoveTo(tg.CreatePoint2d( _ 
                                     points(0).Geometry.X + 0.001, _ 
                                     points(0).Geometry.Y)) 
        points(0).MoveTo(originalPoint) 

        ' Turn off the defer to the sketch will recompute normally.
        sk.DeferUpdates = False 

        trans.End()
    Catch ex As Exception
        sk.DeferUpdates = False 

        If Not trans Is Nothing Then
            trans.Abort()
        End If 

        MsgBox("Unexpected error segmenting curve.")
    End Try
End Sub

Here’s a C# version of the same program.  I’m not going to go into a lot of details now about the differences other than to say that there are several.  I’m working on an upcoming post that will describe the various issues when using C# to program Inventor.  The majority of this code was created using a VB.Net to C# converter, but there were still significant changes that had to be made after that to get it to run.

static void CreateSegmentedCurve(Inventor.Application invApp)
{
    // Check to see that a curved sketch entity is selected.
    SketchEntity entity = null;
    try
    {
        entity = (SketchEntity) invApp.ActiveDocument.SelectSet[1];
    }
    catch 
    {
        MessageBox.Show("A curved sketch entity must be selected.");
        return;
    } 

    if (entity is SketchPoint | entity is SketchLine)
    {
        MessageBox.Show("A curved sketch entity must be selected.");
        return;
    } 

    // Ask for the number of segments to break the curve into.
    string prompt = null;
    prompt = "Enter the number of segments for the curve.";
    int segmentCount = 0;
    segmentCount = (int) Conversion.Val(Interaction.InputBox(prompt,
                              "Number of Segments", "10", 20, 20));
    if (segmentCount == 0)
    {
        MessageBox.Show("Invalid segment count.");
        return;
    } 

    // Get the parent sketch.
    Sketch sk = entity.Parent; 

    // Get the geometry associated with the sketch entity.  Since
    // the Geometry property will return one of various types of
    // objects, we need to use late binding here which C# doesn't
    // handle very nicely.
    object geom = entity.GetType().InvokeMember("Geometry",
                    BindingFlags.GetProperty , null, entity, null); 

    // Get the curve evaluator from the geometry.
      Curve2dEvaluator curveEval =
         (Curve2dEvaluator) geom.GetType().InvokeMember("Evaluator",
          BindingFlags.GetProperty, null, geom, null);

    // Get the evaluator from the associate geometry.
    double minU = 0;
    double maxU = 0;
    curveEval.GetParamExtents(out minU, out maxU); 

    // Determine if the entity is open or closed (circle,
    // ellipse, or closed spline)
    bool curveIsClosed = false;
    if (entity is SketchCircle | entity is SketchEllipse |
        entity is SketchSpline | entity is SketchOffsetSpline)
    {
        if (entity is SketchSpline | entity is SketchOffsetSpline)
        {
            bool isClosed = (bool) entity.GetType().InvokeMember(
                            "Closed", BindingFlags.GetProperty, 
                            null, entity, null);
            if (isClosed)
            {
                curveIsClosed = true;
            }
        }
        else
        {
            curveIsClosed = true;
        }
    }
    TransientGeometry tg = invApp.TransientGeometry; 

    // Determine if start point is at the min or max parameter.
    SketchPoint startPoint = null;
    SketchPoint endPoint = null;
    if (!curveIsClosed)
    {
        // Get the start and end sketch points from the curve.
        SketchPoint tempStartPoint =
                  (SketchPoint) entity.GetType().InvokeMember(
                   "StartSketchPoint", BindingFlags.GetProperty,
                   null, entity, null);
        SketchPoint tempEndPoint =
                  (SketchPoint) entity.GetType().InvokeMember(
                   "StartSketchPoint", BindingFlags.GetProperty,
                   null, entity, null); 
        // Get the coordinate, as a Point object from
        // the start sketch point.
        Point2d tempStartCoord =
                  (Point2d) tempStartPoint.GetType().InvokeMember(
                   "Geometry", BindingFlags.GetProperty, null,
                   tempStartPoint, null); 

        double[] startCoord = {};
        double[] endCoord = {};
        curveEval.GetEndPoints(ref startCoord, ref endCoord);
        if (tempStartCoord.IsEqualTo(tg.CreatePoint2d(startCoord[0],
                                 startCoord[1]), tg.PointTolerance))
        {
            startPoint = tempStartPoint;
            endPoint = tempEndPoint;
        }
        else
        {
            endPoint = tempStartPoint;
            startPoint = tempEndPoint;
        }
    } 

    // Get the curve length.
    double length = 0;
    curveEval.GetLengthAtParam(minU, maxU, out length); 

    // Determine the length between segments.
    double offset = length / segmentCount; 

    // Start a transaction to wrap the sketch creation as a
    // single undo operation.
    Transaction trans = null;
    try
    {
        TransactionManager transMgr = null;
        transMgr = invApp.TransactionManager;
        trans = transMgr.StartTransaction(invApp.ActiveDocument,
                                          "Segment Curve"); 

        // Defer updates on the sketch while the sketch entities
        // are being created.  This will significantly improve
        // performance.
        sk.DeferUpdates = true; 

        // Calculate the points and create a sketch
        // point at each position.
        SketchPoint[] points = new SketchPoint[segmentCount+1];
        double currentLength = 0;
        for (int i = 0; i <= segmentCount; i++) {
            double currentParam = 0;
            curveEval.GetParamAtLength(minU, currentLength,
                                       out currentParam);
            currentLength = currentLength + offset; 

            double[] crvParams = new double[1];
            crvParams[0] = currentParam;
            double[] coords = {};
            curveEval.GetPointAtParam(ref crvParams, ref coords); 

            if (i == 0) {
                // Special case for the first point.
                if (!curveIsClosed) 
                {
                    points[i] = startPoint;
                }
                else
                {
                    points[i] = sk.SketchPoints.Add(
                                tg.CreatePoint2d(coords[0],
                                coords[1]), false);
                    endPoint = points[i];
                }
            }
            else if (i == segmentCount)
            {
                // Special case for the last point
                points[i] = endPoint;
            } 
            else
            {
                points[i] = sk.SketchPoints.Add(
                            tg.CreatePoint2d(coords[0],
                            coords[1]), false);
            }
        } 

        // Connect the points with lines.
        for (int i = 0; i <= segmentCount - 1; i++)
        {
            sk.SketchLines.AddByTwoPoints(points[i], points[i + 1]);
        } 

        // Make the selected entity construction geometry.
        entity.Construction = true; 

        // There's a current problem that when setting the
        // construction property, the display isn't updated to
        // reflect this change until something causes the sketch
        // to recompute.  This performs a change on the sketch to
        // kick a recompute.
        Point2d originalPoint = default(Point2d);
        originalPoint = points[0].Geometry;
        points[0].MoveTo(tg.CreatePoint2d(points[0].Geometry.X +
                                      0.001, points[0].Geometry.Y));
        points[0].MoveTo(originalPoint); 

        // Turn off the defer to the sketch will recompute normally.
        sk.DeferUpdates = false; 

        trans.End();
    }
    catch (Exception)
    {
        sk.DeferUpdates = false; 

        if ((trans != null))
        {
            trans.Abort();
        } 

        MessageBox.Show("Unexpected error segmenting curve.");
    }
}

Approximating a Sketch Curve with Line Segments

Here’s another little VBA macro that I wrote that might be interesting to some of you.  This one takes any sketch curve (circle, arc, spline, ellipse, or elliptical arc) as input, along with the number of segments to break the curve into.  It then creates sketch lines along the curve.  It also sets the original curve to be construction geometry.

This mostly uses the curve geometry query functionality in the API and also demonstrates creating a sketch.  I’ve tried to add comments to the code to help in understanding what it’s doing. 

Public Sub CreateSegmentedCurve()
    ' Check to see that a curved sketch entity is selected.
    Dim entity As SketchEntity
    On Error Resume Next
    Set entity = ThisApplication.ActiveDocument.SelectSet.Item(1)
    If Err.Number <> 0 Then
        MsgBox "A curved sketch entity must be selected."
        Exit Sub
    End If
    On Error GoTo 0 

    If TypeOf entity Is SketchPoint Or _
                                  TypeOf entity Is SketchLine Then
        MsgBox "A curved sketch entity must be selected."
        Exit Sub
    End If 

    ' Ask for the number of segments to break the curve into.
    Dim prompt As String
    prompt = "Enter the number of segments for the curve."
    Dim segmentCount As Integer
    segmentCount = Val(InputBox(prompt, "Number of Segments", "10"))
    If segmentCount = 0 Then
        MsgBox "Invalid segment count."
        Exit Sub
    End If 

    ' Get the parent sketch.
    Dim sk As sketch
    Set sk = entity.Parent 

    ' Get the evaluator from the associate geometry.
    Dim curveEval As Curve2dEvaluator
    Set curveEval = entity.Geometry.Evaluator
    Dim minU As Double
    Dim maxU As Double
    Call curveEval.GetParamExtents(minU, maxU) 

    ' Determine if the entity is open or closed (circle,
    ' ellipse, or closed spline)
    Dim curveIsClosed As Boolean
    curveIsClosed = False
    If TypeOf entity Is SketchCircle Or _
       TypeOf entity Is SketchEllipse Or _
       TypeOf entity Is SketchSpline Or _
       TypeOf entity Is SketchOffsetSpline Then
        If TypeOf entity Is SketchSpline Or _
           TypeOf entity Is SketchOffsetSpline Then
            If entity.Closed Then
                curveIsClosed = True
            End If
        Else
            curveIsClosed = True
        End If
    End If
    Dim tg As TransientGeometry
    Set tg = ThisApplication.TransientGeometry 

    ' Determine if start point is at the min or max parameter.
    Dim startPoint As SketchPoint
    Dim endPoint As SketchPoint
    If Not curveIsClosed Then
        Dim startCoord() As Double
        Dim endCoord() As Double
        Call curveEval.GetEndPoints(startCoord, endCoord)
        If entity.StartSketchPoint.Geometry.IsEqualTo( _
          tg.CreatePoint2d(startCoord(0), startCoord(1))) Then
            Set startPoint = entity.StartSketchPoint
            Set endPoint = entity.EndSketchPoint
        Else
            Set endPoint = entity.StartSketchPoint
            Set startPoint = entity.EndSketchPoint
        End If
    End If 

    ' Get the curve length.
    Dim length As Double
    Call curveEval.GetLengthAtParam(minU, maxU, length) 

    ' Determine the length between segments.
    Dim offset As Double
    offset = length / segmentCount 

    ' Start a transaction to wrap the sketch creation as a
    ' single undo operation.
    On Error GoTo ErrorFound
    Dim transMgr As TransactionManager
    Set transMgr = ThisApplication.TransactionManager
    Dim trans As Transaction
    Set trans = transMgr.StartTransaction( _
                    ThisApplication.ActiveDocument, "Segment Curve") 

    ' Defer updates on the sketch while the sketch entities
    ' are being created.  This will significantly improve
    ' performance.
    sk.DeferUpdates = True 

    ' Calculate the points and create a sketch
    ' point at each position.
    Dim points() As SketchPoint
    ReDim points(segmentCount)
    Dim i As Integer
    Dim currentLength As Double
    currentLength = 0
    For i = 0 To segmentCount
        Dim currentParam As Double
        Call curveEval.GetParamAtLength(minU, currentLength, _
                                        currentParam)
        currentLength = currentLength + offset 

        Dim params(0) As Double
        params(0) = currentParam
        Dim coords() As Double
        Call curveEval.GetPointAtParam(params, coords) 

        If i = 0 Then
            ' Special case for first point.
            If Not curveIsClosed Then
                Set points(i) = startPoint
            Else
                Set points(i) = sk.SketchPoints.Add( _
                       tg.CreatePoint2d(coords(0), coords(1)), False)
                Set endPoint = points(i)
            End If
        ElseIf i = segmentCount Then
            ' Special case for last point
            Set points(i) = endPoint
        Else
            Set points(i) = sk.SketchPoints.Add( _
                       tg.CreatePoint2d(coords(0), coords(1)), False)
        End If
    Next 

    ' Connect the points with lines.
    For i = 0 To segmentCount - 1
        Call sk.SketchLines.AddByTwoPoints(points(i), points(i + 1))
    Next 

    ' Make the selected entity construction geometry.
    entity.Construction = True

    ' There's a current problem that when setting the construction
    ' property, the display isn't updated to reflect this change
    ' until something causes the sketch to recompute.  This performs
    ' a change on the sketch to kick a recompute.
    Dim originalPoint As Point2d
    Set originalPoint = points(0).Geometry
    Call points(0).MoveTo(tg.CreatePoint2d( _
                                   points(0).Geometry.X + 0.001, _
                                   points(0).Geometry.Y))
    Call points(0).MoveTo(originalPoint) 

    ' Turn off the defer to the sketch will recompute normally.
    sk.DeferUpdates = False 

    trans.End
    Exit Sub

ErrorFound:
    sk.DeferUpdates = False 

    If Not trans Is Nothing Then
        trans.Abort
    End If 

    MsgBox "Unexpected error segmenting curve."
End Sub

Saving Files as an Image (bmp, jpg, png, tiff, gif)

I was recently asked if I had a macro that would create a jpg file for each part in a directory.  The code below is what I came up with.  It finds all of the files of a certain type within a specified directory and creates an image file for each one. 

The primary function this macro uses to accomplish this is the SaveAsBitmap method.  This method is on the View object, which represents a graphics window.  The SaveAsBitmap method saves the contents of that window as an image.  You can specify one of several different image types and you can also specify the size of the output image.  The supported image types are bmp, jpg, png, tiff, and gif.  The type to write out is inferred by the extension of the image file you specify.  The sample below will create jpg files.  Being able to specify the size of the output image is also powerful because then you’re not limited by the size of the window and the resulting image is not just a scaled bitmap of the current window contents  but is an image rendered specifically at the specified size.

It’s also very simple in that there isn’t any user-interface.  All inputs, the directory to process and the input and output file types, are hard-coded within the program.

Public Sub SaveImages()
    ' Specify the size of the output image in pixels.  If you
    ' use zero then it will be the actual size of the window.
    Dim pixelWidth As Integer
    Dim pixelHeight As Integer
    pixelWidth = 800
    pixelHeight = 800

    ' Specify the path where the files exist.  The rest of the
    ' code expects this path name to end with a backslash.
    Dim dirName As String
    dirName = "C:\Temp\"

    ' Loop through the files in the specified directory.
    ' Depending on the file type you want to generate the
    ' images for you may need to change the file extension.
    ' In this case it will create images for all the part
    ' files in the specified directory.  Editing "*.ipt" to
    ' "*.iam" will generate images for all assemblies.
    Dim filename As String
    filename = Dir(dirName & "*.ipt")
    Do While filename <> ""
        ' Save the current silent operation state.
        Dim silentState As Boolean
        silentState = ThisApplication.SilentOperation

        ' Turn on silent operation.
        ThisApplication.SilentOperation = True

        ' Open the document.
        Dim doc As Document
        Set doc = ThisApplication.Documents.Open(dirName & filename)

        ' Restore the state to its previous value.
        ThisApplication.SilentOperation = silentState

        ' Get the currently active view, which will be for
        ' the document just opened.
        Dim window As view
        Set window = ThisApplication.ActiveView

        ' Create the filename for the output file.  This uses
        ' the same name as the original file and replaces the
        ' extension with .jpg
        Dim imageFilename As String
        imageFilename = dirName & _
                        Left$(filename, InStr(filename, ".")) & "jpg"
        Call window.SaveAsBitmap(imageFilename, _
                                 pixelWidth, pixelHeight)

        ' Close the current document.
        Call doc.Close(True)

        ' Get the next filename.
        filename = Dir
    Loop

    ThisApplication.StatusBarText = "Finished processing."
End Sub

iProperty Name Table

I thought I would share something that I use frequently and have found very useful.  It’s a listing of Inventor’s iProperties and the sets they’re grouped within.  I keep a printout of this at my desk that I refer to frequently when I’m writing programs that use iProperties.  I included a version of this table as part of an earlier post covering the basics of iProperties, but I find it useful to have a printed version handy that I can quickly refer to.

Here’s the single page pdf file that has the iProperty name table.  Hopefully you’ll find it as useful as I have.