Mod the Machine

Using VBA Sample Code (for the Non-Programmer)

You don’t know anything about VBA but you’ve found some interesting VBA code somewhere on the web, in a newsgroup, or maybe even here.  So now what do you do with that code to be able to use it in Inventor?  Here are the cookbook steps:

1. From within Inventor, press Alt-F11 or run the VBA Editor command from the Tools tab of the ribbon.  This will open the VBA development environment, as seen below.

   

2. The Project Explorer is the window containing the tree at the upper-left in the picture. 
   • Expand the node labeled “ApplicationProject”. 
   • Expand the node labeled “Modules”
   • Double-click on the node labeled “Module1”
     An editor window will pop-up, similar to the picture below. (In the picture below I have one document open so there are two top-level nodes in the project explorer.  One node is for the application project and the other node is for the document.  Make sure you use the application project.)
     
   

3. Go to wherever the original VBA code is (browser, new reader, email, etc.) and copy it to the clipboard.
   
4. Click within the VBA code window and paste the code.  You should see something similar to the picture below.

   

5. Scan through the code to see if there are any problems.  Do this by scrolling down through the pasted code looking for any red lines.  If you don’t see any problems go to step 6, otherwise continue with this step.

   The most common issue when pasting code is that lines that should be a single line may end up wrapping onto two lines.  VBA expects a statement to be on a single line.  The example below illustrates the problem where what should be a single line has been broken and wraps onto the next line.

   

   Fix it by editing it so it is on a single line.

   There’s also an exception to the statement I made above about the requirement of a statement only being a single line.  It’s possible to break a statement into multiple lines by adding a “ _” (space and underscore) at the end of a line.  This is a line continuation character and indicates that the statement continues on the next line.  That’s shown in the top statement in the previous picture.  You may need to understand that to better understand why a line is shown in red.
   
   If you see other problems, it beyond the scope of this post to diagnose those.  It would be best to go back to the author or to ask someone that has some familiarity with the API.

6. Close the VBA window.
   
7. Run the program by pressing Alt-F8 or running the Macros command from the Tools tab.  This will display the Macros dialog, as shown below.

   

8. In the “Macros in” drop-down list select “Application Project” and choose the macro you want to run from the list, as shown below.

   

9. Click the “Run” button.

For some other ways to execute a macro see the post Creating Buttons for VBA Macros.

VBA Code Writing Tip

This week has been busy and left me with little time to work on finishing up some posts I’ve been working on.  Here’s a quick tip that can make coding in VBA or VB6 a little easier.  Maybe you already know about it, but it’s something I didn’t learn about until I had been using VBA and VB6 for several years.

When you’re entering code in a VBA code window you get Intellisense help when accessing methods and properties on objects.  VB.Net uses intellisense to help you when typing variable names.  You can also get help with variable names in VBA, it’s just not automatic like it is in VB.Net.  When you’ve typed the first few characters of a variable, press ctrl-space and the intellisense window will display showing you the available variable names that match the characters you’ve typed in so far.  You can continue typing to narrow down the list or choose one from the list.  Once you’ve selected one from the list by clicking with the mouse or using the arrow keys, press the tab key to use it.  An example of its use is shown below.

The written description makes it sound like a bit difficult to use with a lot of steps  but it quickly became second nature for me and has saved me a lot of typing.

Buttons for VBA Macros in the Ribbon User-Interface

There’s a previous post that describes various ways to run a VBA macro, with a  portion of that post discussing how to create a button to execute a macro.  That post describes the process of creating a button for the classic user-interface but the process is different for the ribbon user-interface.  This post describes the differences when using the ribbon.

To create a button to execute a VBA macro in the ribbon user-interface you use the Customize User Commands command which you access by right-clicking anywhere on the ribbon, as shown below.

The command displays the dialog shown below.  To choose a VBA macro select “Macros” in the drop-down in the upper-left corner of the dialog.  The list of commands will now show all of the VBA macros in the application project.  Select the desired macro and then click the “Add >>” button in the middle of the dialog.  You can continue to select and add other macros and then click OK when finished.

Buttons for the selected macros are added to a new panel, as shown below.  The “User Commands” panel is added to the currently active ribbon tab, so by choosing which tab to add the macros to you have some control over when the command is available.  If you need it in more than one tab, you’ll need to go through the process  for each tab.

 

As explained in the other post, you can assign your own icons, as I’ve done in this example.  This is done in exactly the same way as described before, by creating a bmp file, saving it in the same directory as the .ivb file, and naming it correctly.  One thing to be aware of is that you don’t have control over whether the button will be displayed as a large or small button; it’s always small.  Because of that the bitmap you create should be 16x16 pixels and should be named “ModuleName.MacroName.Small.bmp”.  Unfortunately, you don’t have the option of displaying text with the button.  Having a recognizable icon will help with this and the tooltip for the button displays the name of the macro.

Removing VBA Document Projects From Inventor Files

I received an email recently with a question that relates back to a series of past postings in this blog.  They used the previous blog postings to migrate their document macros to an add-in but are now wondering how to remove their document macros from their files.  There are three approaches that I'm aware of to do this.  With all of these make sure you have a back up of the file before deleting the macros.

First, you can manually open each document and use the VBA editor to delete the code from the document project.  This is fine if you only have a handful of documents but is tedious if you have many documents.  The advantages to this approach is that it's simple and also gives you the flexibility to look at the macros within the document and decide one-by-one whether to delete and/or to copy the macro to the application project.

Second, you can use a VBA macro to automate the deletion.  Here's a VBA macro that I wrote using the functionality provided by Inventor's API and the VBA Extensibility library to manipulate a VBA project.  It either comments or deletes all automatic macros from the specified VBA project.  You could easily wrap this to open, process, and save many documents.  This will leave any other macros in the project alone.  There are some cases where you might have a regular macro (vs. an auto macro) that is specific to that document and you don't want to delete it.  To use the macro below, copy and paste it into your application project and add a reference to the Microsoft Visual Basic for Applications Extensibility 5.3 library.

' Sub to test the DeleteAutoMacros sub.
Public Sub TestDeleteAutoMacros()
    Dim oActiveDocument As Document
    Set oActiveDocument = ThisApplication.activeDocument
    Call DeleteAutoMacros(oActiveDocument.VBAProject, True)
End Sub

' Given an Inventor VBA project as input, this
' deletes or comments the code for all of the
' automatic macros contained within the project.
Private Sub DeleteAutoMacros( _
                         ByVal VBAProject As InventorVBAProject, _
                         Optional ByVal Comment As Boolean = True)
   ' Iterate through the modules of the document project.
   Dim oModule As InventorVBAComponent
   For Each oModule In VBAProject.InventorVBAComponents
      ' Check to see if this is a code module or document module.
      If oModule.VBComponent.Type = vbext_ct_StdModule Or _
         oModule.VBComponent.Type = vbext_ct_Document Then
         ' Look for any auto macros.
         Dim oFunction As InventorVBAMember
         For Each oFunction In oModule.InventorVBAMembers
            ' Check that this is an automatic macro.
            Select Case LCase(oFunction.Name)
            Case "autosave", "autoopen", "autonew", _
                 "autoclose", "autoedit"
               ' Get the VBIDE object that represents the module.
               Dim oVBCodeModule As codeModule
               Set oVBCodeModule = oModule.VBComponent.codeModule

               ' Get the start line and length of the module.
               Dim iStartLine As Long
               iStartLine = oVBCodeModule.ProcStartLine( _
                                  oFunction.Name, vbext_pk_Proc)
               Dim iNumLines As Long
               iNumLines = oVBCodeModule.ProcCountLines( _
                                  oFunction.Name, vbext_pk_Proc)

               If Comment Then
                  ' Get the macro as a string.
                  Dim strMacroLines As String
                  strMacroLines = oVBCodeModule.Lines( _
                                           iStartLine, iNumLines)

                  ' Insert a comment at the beginning line.
                  strMacroLines = "' " & strMacroLines

                  ' Add a comment at the beginning of each line.
                  strMacroLines = Replace(strMacroLines, _
                                       vbCrLf, vbCr & "' ")

                  ' Delete the existing macro.
                  Call oVBCodeModule.DeleteLines(iStartLine, _
                                                 iNumLines)

                  ' Add the commented version of the macro.
                  Call oVBCodeModule.InsertLines(iStartLine, _
                                                 strMacroLines)
               Else
                  ' Delete the lines.
                  Call oVBCodeModule.DeleteLines(iStartLine, _
                                                 iNumLines)
               End If
            End Select
         Next
      End If
   Next
End Sub

The third option is to use this Delete VBA utility to completely remove the VBA project from the document.  It's a command line utility.  Just supply the filename of the Inventor file as an argument when run from the command line.  The zip file in the link contains the program and the source code.  To use it you only need the DeleteVBA.exe file.  If you're sure you don't have any other VBA code in the document that you care about this is the best option.

Creating Buttons for VBA Macros

What is a Macro?

The title for this posting is specific to a question that's come up a couple of times recently, but the post is actually more general and covers the many ways you can execute an Inventor VBA macro.

First, let's define what a macro is.  It's a public sub without any arguments within a standard code module in an Inventor VBA project.  The following code shows a valid macro.  It's declared as a Public sub with no arguments.

Public Sub SampleMacro()
    MsgBox "The macro is running."
End Sub

The following is also a valid macro since subs default to being Public if you don't specify it to be Public or Private.

Sub SampleMacro()
    MsgBox "The macro is running."
End Sub

The following is not a valid macro since it has arguments.

Public Sub AddNumbers(Value1 As Double, Value2 As Double)
    MsgBox "Value sum: " & Value1 + Value2
End Sub

Standard code modules are shown in the project window under the Modules node in the tree, as shown below.  You can have any number of code modules within a project and all new projects will contain a module named "Module1".  A macro can exist in any module.

VBA's Project window and a code module.

 

Running a Macro Using the Macros Command

One interface you can use to run a VBA macro is the Macros command (Tools -> Macro -> Macros... or Alt-F8).  Running this command will display the dialog shown below.  This dialog displays a list of all of the available macros.  It lists them as ModuleName.MacroName.  The "Macros in" drop-down list let you select different VBA projects.  To run a macro, select it in the list and click the Run button.

The Macros command dialog.

This interface is always available to run a macro but is not the most convenient or easiest to use, especially if you have macros that you frequently use.

Running a Macro Using a Button

For frequently used macros it's much more convenient to create a button to execute the macro.  To create a button for a macro there's one additional requirement on your macro.  It must exist in the default VBA project.  This is the VBA project that Inventor loads automatically every time it is started.  It's likely that your macro is already in this project.  The default VBA project is defined using the File tab of Application Options command, as shown below.  In this case it is Default.ivb in the Bin\Macros directory, but it can be any .ivb file.

Specifying the default VBA project.

 

To create a button use the Customize command (Tools -> Customize...) and select the Commands tab of the dialog.  In the Categories list there is a "Macros" category.  After selecting that you'll see a list of available macros in the Commands list on the right.  You can drag and drop any of the macros in the list onto any available toolbar, including the panel bar.  This is illustrated in the picture below.

Using the Customize command to create a macro button.

 

It's easy to create a button for your macro but it will have a default icon that's used for all VBA macros.  If you have more than one macro button it can be difficult to tell which button is for which macro.  The tool tip for the button does display the macro name, however it's also possible to create your own icon for a macro button.

Icons are created using whatever bitmap editor you choose.  The Paint program that comes with Windows will work.  Create a bitmap that is 16x16 pixels in size.  It can use any colors but magenta is interpreted as the transparent color.  Below is an example.  The picture on the left shows the icon (zoomed in) within the Paint program.  The picture on the right shows the same icon used for a button.  Notice that the magenta color has become the background color.

  

Icon samples.

 

To associate an icon with a macro you must name it correctly and put it in the correct location.  The rules for naming are:

   ModuleName.MacroName.Size.bmp

The ModuleName is the name of the VBA module where your macro is.  In this example it is "Module1".  The MacroName is the name of your macro.  In this example it is "SampleMacro".  The Size can be either "Small" or "Large".  Small icons are 16x16 pixels and large icons are 32x32 pixels.  Inventor allows the end-user to choose to use large or small icons.  If you only supply a small icon Inventor will scale it and create a large icon if needed.  For the example above you would create a 16x16 pixel bitmap called:

   Module1.SampleMacro.Small.bmp

The large bitmap name is:

   Module1.SampleMacro.Large.bmp

These files need to be located in the same directory as Default.ivb (or your default VBA project).  Inventor will automatically associate them with the macro when creating a button.  If your icon does not display then double-check the name and the size of the icon.

 

Running a Macro from a Program

Although not commonly used, it's also possible to run a macro from another program.  This isn't limited to running only macros, as defined above, but any function or sub in any project and module can be executed.  I won't go into a lot of detail since there is likely not much interest in this but here is an example that demonstrates the process.  First, here are two macros in Inventor's default VBA project.

Public Sub SampleMacro()
    MsgBox "The macro is running."
End Sub

Public Sub AddNumbers(Value1 As Double, Value2 As Double)
    MsgBox "Value sum: " & Value1 + Value2
End Sub

Here is an Excel macro that connects to Inventor and executes the two Inventor macros.

Public Sub RunInventorMacros()    
    ' Get a reference to Inventor.  This assumes Inventor is running.
     Dim invApp As Inventor.Application
    Set invApp = GetObject(, "Inventor.Application")

    ' Get a reference to the default VBA project.
    ' It will always be the first item in the collection.
    Dim invVBAProject As InventorVBAProject
    Set invVBAProject = invApp.VBAProjects.Item(1)

    ' Get a reference to the Module1 code module.
    Dim invModule As InventorVBAComponent
    Set invModule = invVBAProject.InventorVBAComponents.Item("Module1")

    ' Get a reference to the SampleMacro sub.
    Dim invSub As InventorVBAMember
    Set invSub = invModule.InventorVBAMembers.Item("SampleMacro")

    ' Execute the macro.
    invSub.Execute

    ' Get a reference to the AddNumbers sub.
    Set invSub = invModule.InventorVBAMembers.Item("AddNumbers")

    ' Set the arguments.
    invSub.Arguments.Item("Value1").Value = 3.5
    invSub.Arguments.Item("Value2").Value = 4.75

    ' Execute the sub
    Call invSub.Execute
End Sub

Converting VBA Auto Macros to an Add-In

This posting assumes you have a VBA auto macro and want to quit using the auto macro functionality and convert it to an add-in. See the previous posting VBA Document Projects as to why you might want to do this.  Without a lot of explanation, here are the prerequisites and the steps required to create the add-in.

Here is an example of an automatic macro that exists within a drawing document. It automatically writes out dwf and pdf files of the drawing whenever the drawing is saved.  The rest of this post looks at the process to create an add-in to replace this auto macro.

Public Sub AutoSave()
    ' Get the filename minus the extension.
    Dim strFilename As String
    strFilename = ThisDocument.FullFileName
    strFilename = Left(strFilename, Len(strFilename) - 4)

    ' Save the current SilentOperation and then turn it on.
    ' This will suppress the dwf viewer from being displayed.
    Dim currentSetting As Boolean
    currentSetting = ThisApplication.SilentOperation
    ThisApplication.SilentOperation = True

    ' Save the file as dwf.
    Call ThisDocument.SaveAs(strFilename & ".dwf", True)

    ' Reset SilentOperation back to its previous value.
    ThisApplication.SilentOperation = currentSetting

    ' Save the file as pdf.
    Call ThisDocument.SaveAs(strFilename & ".pdf", True)
End Sub

What You'll Need

A Programming Language - To write an add-in you need to use a language that supports creating COM components. For this example I'll illustrate the process using both Visual Basic 2008 and C# 2008. Microsoft provides free Express versions of both of these languages. You can install them from the Microsoft web site. Microsoft also provides online training resources for learning these languages. If this is all new to you and you don't know which one to get I would recommend Visual Basic, but it really is a personal preference.

Inventor SDK Developer Tools - You'll also need some Inventor specific development tools.  This is delivered when you install Inventor but you need to run its setup to install it. Assuming you're using Inventor 2009, locate the following file in Explorer and run it:

C:\Program Files\Autodesk\Inventor 2009\SDK\DeveloperTools.msi

Inventor 2009 was released when Visual Studio 2005 was the current development platform. Because of that the Add-In wizard provided with it does not get installed for use with Visual Studio 2008.  To work around this you can copy the files below to the specified directories.  Don't unzip the files but just copy the file as-is.

VB 2008
Copy VBInventorAddInTemplate.zip to 
"My Documents\Visual Studio 2008\Templates\ProjectTemplates"

C# 2008
Copy VCSInventorAddInTemplate.zip to 
"My Documents\Visual Studio 2008\Templates\ProjectTemplates"

Creating the Add-In

The add-in is created using the add-in template. Start VB or C# and choose to create a new project. For the template choose "Autodesk Inventor AddIn", as shown below. You can also specify the name of the add-in at this point, ("AutoSaveAddIn" in the example below).

 

In the Visual Studio Solution Explorer you'll see the various files listed that were created for the project. For a Visual Basic add-in, most of the code is in the StandardAddInServer.vb file and for a C# add-in it is in the StandardAddInServer.cs file. Double-click on this file to open it in the code editor. You should see something very similar to one of the pictures below. Your GuidAttribute value will be different than those shown below since that is unique for every add-in.

 
Visual Basic Code Window

Visual C# Code Window

Editing the Name and Description of the Add-In

One common thing you'll want to do when creating an add-in is to define the name and description of the add-in as it will be seen in the Add-In Manager. You do this by editing the code in the "COM Registration" block of the code. Click on the "+" next to this region to expand it. The code in red is the portion I've changed to modify the name and the description. The code below is from the VB add-in but the C# code is almost identical and it will be obvious what to edit.

Public Shared Sub Register(ByVal t As Type)
   Dim clssRoot As RegistryKey = Registry.ClassesRoot
   Dim clsid As RegistryKey = Nothing
   Dim subKey As RegistryKey = Nothing
   Try
      clsid = clssRoot.CreateSubKey("CLSID\" + AddInGuid(t))
      clsid.SetValue(Nothing, "Automated DWF and PDF Save")
      subKey = clsid.CreateSubKey( _  
    "Implemented Categories\{39AD2B5C-7A29-11D6-8E0A-0010B541CAA8}")
      subKey.Close()       subKey = clsid.CreateSubKey("Settings")
      subKey.SetValue("AddInType", "Standard")
      subKey.SetValue("LoadOnStartUp", "1")
      'subKey.SetValue("SupportedSoftwareVersionLessThan", "")
      subKey.SetValue("SupportedSoftwareVersionGreaterThan", "12..")
      'subKey.SetValue("SupportedSoftwareVersionEqualTo", "")
      'subKey.SetValue("SupportedSoftwareVersionNotEqualTo", "")
      'subKey.SetValue("Hidden", "0")
      'subKey.SetValue("UserUnloadable", "1")
      subKey.SetValue("Version", 0)
      subKey.Close()
      subKey = clsid.CreateSubKey("Description")
      subKey.SetValue(Nothing, "Saves drawings as DWF and PDF.")
   Catch ex As Exception
      System.Diagnostics.Trace.Assert(False)
   Finally
      If Not subKey Is Nothing Then subKey.Close()
      If Not clsid Is Nothing Then clsid.Close()
      If Not clssRoot Is Nothing Then clssRoot.Close()
   End Try
End Sub

Reacting to Events in Visual Basic

Now we can add the code that will react anytime a document is saved. For a VB add-in, add the code below that's shown in red. The second line is in the "ApplicationAddInServer Members" code region so you'll need to expand that region to see the code.  The code consists of a declaration and an assignment.

Public Class StandardAddInServer
   Implements Inventor.ApplicationAddInServer
   ' Inventor application object.
   Private m_inventorApplication As Inventor.Application
   Private WithEvents m_appEvents As Inventor.ApplicationEvents

#Region "ApplicationAddInServer Members"
   Public Sub Activate( _

          ByVal addInSiteObject As Inventor.ApplicationAddInSite, _ 
          ByVal firstTime As Boolean) _

               Implements Inventor.ApplicationAddInServer.Activate
       ' Initialize AddIn members.
       m_inventorApplication = addInSiteObject.Application
       m_appEvents = m_inventorApplication.ApplicationEvents
   End Sub

At the top of the code window are two combo boxes. The one on the left displays a list of classes and the one on the right displays a list of methods for the selected class. Choose "m_appEvents" on the left and "OnSaveDocument" on the right, as shown below. This will insert the sub m_appEvents_OnsaveDocument as shown below. This is the event handler for the OnSaveDocument event will be called whenever a document is saved in Inventor.

 

Here's code that's equivalent to the original AutoSave macro. This performs a couple of additional checks that the original automatic macro didn't need to do. First, the OnSaveDocument is fired before and after the document is actually saved.  This listens for when the event is fired after the Inventor save. The event is also fired whenever any document is saved. This looks for and only handles drawing documents.

Private Sub m_appEvents_OnSaveDocument( _                  
               ByVal DocumentObject As Inventor._Document, _  
               ByVal BeforeOrAfter As Inventor.EventTimingEnum, _  
               ByVal Context As Inventor.NameValueMap, _  
               ByRef HandlingCode As Inventor.HandlingCodeEnum) _  
                                  Handles m_appEvents.OnSaveDocument 
  If BeforeOrAfter = EventTimingEnum.kAfter Then 
    If DocumentObject.DocumentType = DocumentTypeEnum.kDrawingDocumentObject Then 
      ' Get the filename minus the extension. 
      Dim filename As String 
      filename = DocumentObject.FullFileName 
      filename = Left(filename, Len(filename) - 4) 

      ' Save the current SilentOperation and then turn it on.  
      ' This will suppress the dwf viewer from being displayed.  
      Dim currentSetting As Boolean  
      currentSetting = m_inventorApplication.SilentOperation  
      m_inventorApplication.SilentOperation = True 

      ' Save the file as dwf.  
      DocumentObject.SaveAs(filename & ".dwf", True)  

      ' Save the file as pdf.  
      DocumentObject.SaveAs(filename & ".pdf", True)  

      ' Reset SilentOperation back to its previous value.  
      m_inventorApplication.SilentOperation = currentSetting 
    End If  
  End If
End Sub

Reacting to Events in C#

The code highlighted in red below was added to support handling the save event in C#.  The last two lines are in the "ApplicationAddInServer Members" code region so you'll need to expand that region to see the code.  The line where the delegate is created to handle the event is mostly created by using Intellisense.  Go slowly as you type and you'll see options pop up that allow you to press the tab key to create much of the code.

private Inventor.Application m_inventorApplication;
private Inventor.ApplicationEvents m_appEvents = null;

public StandardAddInServer()
{
}
#region ApplicationAddInServer Members

public void Activate(

               Inventor.ApplicationAddInSite addInSiteObject,

               bool firstTime)
{
   // Initialize AddIn members.
   m_inventorApplication = addInSiteObject.Application;
   m_appEvents = m_inventorApplication.ApplicationEvents;

   // Create the delegate object to handle the event.
   m_appEvents.OnSaveDocument += new 
        ApplicationEventsSink_OnSaveDocumentEventHandler(

                                     m_appEvents_OnSaveDocument);
}

Intellisense can also create the event implementation code as you're typing the line above.  Below is the code it created with the additional code in red that I added to save the dwf and pdf files.

void m_appEvents_OnSaveDocument(_Document DocumentObject,

                EventTimingEnum BeforeOrAfter,

                NameValueMap Context,

                out HandlingCodeEnum HandlingCode)
{
   // A value has to be returned for the handling code.
   HandlingCode = HandlingCodeEnum.kEventNotHandled;

   if (BeforeOrAfter == EventTimingEnum.kAfter)
   {
      if (DocumentObject.DocumentType == DocumentTypeEnum.kDrawingDocumentObject)
      {
         // Get the filename minus the extension.
         String filename = DocumentObject.FullFileName;
         filename = filename.Substring(0, filename.Length - 4);

         // Save the current SilentOperation and then turn it on.
         // This will suppress the dwf viewer from being displayed.
         Boolean currentSetting = m_inventorApplication.SilentOperation;
         m_inventorApplication.SilentOperation = true;

         // Save the file as dwf.
         DocumentObject.SaveAs(filename + ".dwf", true); 

         // Save the file as pdf.
         DocumentObject.SaveAs(filename + ".pdf", true);

         // Reset SilentOperation back to its previous value.
         m_inventorApplication.SilentOperation = currentSetting; 
      }
   }
}

Cleaning Up

Finally, just a bit of code to clean up everything when the add-in is unloaded.  This is in the Deactivate method of the add-in.  The code I added is in red.

Public Sub Deactivate() Implements Inventor.ApplicationAddInServer.Deactivate
   ' Release objects.
   Marshal.ReleaseComObject(m_appEvents)
   m_appEvents = Nothing

   Marshal.ReleaseComObject(m_inventorApplication)
   m_inventorApplication = Nothing

   System.GC.WaitForPendingFinalizers()
   System.GC.Collect()
End Sub

Here's the equivalent code for C#.

public void Deactivate()
{
   // Disconnect the event delegate.
   m_appEvents.OnSaveDocument -= new
       ApplicationEventsSink_OnSaveDocumentEventHandler(

                                m_appEvents_OnSaveDocument);

   // Release objects.
   Marshal.ReleaseComObject(m_appEvents);
   m_appEvents = null;
   Marshal.ReleaseComObject(m_inventorApplication);
   m_inventorApplication = null;

   GC.WaitForPendingFinalizers();
   GC.Collect();
}

Using the Add-In

Now all you need to do is build the add-in.   Building the add-in creates the dll and also registers it.  When you run Inventor you should see the add-in in the Add-In Manager and when you save a drawing document the corresponding pdf and dwf files will also be created.

To use the add-in on another computer you need to copy the add-in dll to that computer and register it.  Below are some commands you can use within .bat files to both register and unregister the add-in for 32 and 64-bit installations.

Register on 32-bit

@echo off
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\RegAsm.exe /codebase AutoSaveAddIn.dll
PAUSE

Unregister on 32-bit

@echo off
C:\WINDOWS\Microsoft.NET\Framework\v2.0.50727\RegAsm.exe /unregister AutoSaveAddIn.dll
PAUSE

Register on 64-bit

@echo off
C:\WINDOWS\Microsoft.NET\Framework64\v2.0.50727\RegAsm.exe /codebase AutoSaveAddIn.dll
PAUSE

Unregister on 64-bit

@echo off
C:\WINDOWS\Microsoft.NET\Framework64\v2.0.50727\RegAsm.exe /unregister AutoSaveAddIn.dll
PAUSE

When you test the add-in you can't just open an existing drawing, immediately save it, and expect to see the dwf and pdf files.  The reason is because the drawing hasn't changed so clicking the save button doesn't do anything.  If you make any change to the drawing, i.e. edit an iProperty or move a view or dimension, the OnSaveDocument event is fired and the additional files will be created.

VBA Document Projects

Inventor's implementation of VBA supports two types of VBA projects; document projects and external projects.  They're defined by where the project is saved.  Document VBA projects are saved within Inventor documents, parts, assemblies, etc.  External projects are saved as individual .ivb files.  Using the File tab of the Application Options dialog you can specify one external project to be loaded automatically when Inventor starts up.  This VBA project is frequently referred to as the application project.

When VBA was integrated into Inventor we looked at other VBA integrations for ideas.  All of the applications that supported VBA that I had used at the time all used the idea of document projects so it seemed like that was something we needed to provide as part of Inventor's implementation.  However, when I had used some of these applications that only had document projects I didn't like them because it made maintaining code almost impossible.  For example, I was writing a reasonably large program in one of the applications and it was stored within a document.  I would copy that document to use the program with other sets of data.  When I wanted to make a fix or enhancement to the program I had multiple copies of it and didn't know which version of the program existed where.  As a result of this frustration we also added support for external projects in Inventor's implementation of VBA.

A feature of the document macros that Word and Excel supported that seemed good was the idea of automatic macros.  These are macros with a particular name that are run automatically when something happens in the application.  For example, when a document is opened or saved a macro is run.  This functionality makes it very easy for someone with limited programming experience to write a simple macro to respond to these events in Inventor.

A couple of releases after we added VBA to Inventor we started getting reports of some problems.  The problem turned out to be a resource issue with VBA.  People were creating document projects that used automatic macros and were using these Inventor documents that contained these projects as their templates.  That meant that every file they created had a VBA document project.  When a large assembly is loaded all of the referenced documents are also loaded, and in the case of these documents also meant loading the embedded VBA projects.  It turns out that VBA has a limit to the number of VBA projects that can be loaded.

The other significant problem to having document macros in a template is that it creates the problem I already talked about of having your program duplicated in all your documents making it very difficult to fix or enhance that program.  There is also another problem that recently came up with document projects and 64 bit Inventor.

My advice is: DO NOT USE document projects.  The one exception to this is if you're writing a program that is very specific to a single document.  For example if you have a part and write a specific program to work with only that part.  In this case it's convenient to package the program with the document rather than worry about passing an additional file with it.

External VBA projects should provide most of the functionality you would want and also provide the additional capability that you can create toolbar buttons to run the macros contained within them.  What external VBA projects don't provide is the ability to do the equivalent of automatic macros.  The best answer for this is to create an Add-In.  (There have been some Add-In utilities written that add support for automatic macros to VBA external projects but I've found for most people that these end up being confusing because they don't understand how they work and as a result don't know how to debug and diagnose problems when they occur.)  An Add-In allows you to do anything you could do in VBA and more.  The downside of an Add-In is that there's a higher learning curve to getting started.

In my next posting I'll cover what's required to create an Add-In that replaces an existing automatic macro.