Manufacturing DevBlog

Import and save non-native files

By Adam Nagy

When you import a non-native file then you are using a translator add-in to do the import. Each of them might have different options which can affect how you implement things.

As shown in this blog post you can easily find out all the options available for a translator add-in:
http://adndevblog.typepad.com/manufacturing/2014/02/get-option-names-and-values-supported-by-inventor-translator-addins-via-api.html 

For SolidWorks translator add-in's open options you'd get something like this in Inventor 2016:

SaveComponentDuringLoad
 True
SaveLocationIndex
  1 
ComponentDestFolder
 C:\Users\adamnagy\Documents\Inventor\SW\
AssemDestFolder
 C:\Users\adamnagy\Documents\Inventor\SW\
SaveAssemSeperateFolder
 False
AddFilenamePrefix
 False
FilenamePrefix
 
AddFilenameSuffix
 False
FilenameSuffix
 
EmbedInDocument
 True
SaveToDisk
 False
ImportSolid
 True
ImportSurface
 True
ImportWire
 True
CreateIFO
 False
ImportAASP
 False
ImportAASPIndex
  0 
CreateSurfIndex
  1 
GroupName
 
GroupNameIndex
  0 
ExplodeMSB2Assm
 False
ImportUnit
  0 
CheckDuringLoad
 False
AutoStitchAndPromote
 True
AdvanceHealing
 False
EdgeSplitAndMergeDisabled
 False
FaceSplitAndMergeDisabled
 False
AssociativeImport
 False
Selective Import
 False
Link Visibility
 True

E.g. if you want to import a complete SolidWorks assembly and save the created Inventor files, then the translator has an option for that. You can specify where the created files should be placed and also if they should be saved during the creation of those files, so you don't even have to iterate through them and save them - actually if you save the main assembly and use
Application.SilentOperation = True, that should do the trick too.  

The following code can automate the whole import and save part:

Sub ImportAndSaveSolidWorksFiles()
  Dim oAddIns As ApplicationAddIns
  Set oAddIns = ThisApplication.ApplicationAddIns

  ' SolidWorks translator addin
  Dim oTA As TranslatorAddIn
  Set oTA = oAddIns.ItemById("{402BE503-725D-41CB-B746-D557AB83BAF1}")
  
  ' Activate if needed
  If Not oTA.Activated Then oTA.Activate
  
  Dim oTO As TransientObjects
  Set oTO = ThisApplication.TransientObjects
  
  Dim oDM As DataMedium
  Set oDM = oTO.CreateDataMedium
  oDM.FileName = "C:\Gears\gears.SLDASM"
 
  Dim oTC As TranslationContext
  Set oTC = oTO.CreateTranslationContext
  oTC.Type = kFileBrowseIOMechanism
 
  Dim oNVM As NameValueMap
  Set oNVM = oTO.CreateNameValueMap
 
  ' Show the options dialog if you want
  ' Call oTA.ShowOpenOptions(oDM, oTC, oNVM)
  ' and print out the available options
  ' Call PrintInfo(oNVM, 1)
  
  ' Set the options we need
  Call oNVM.Add("SaveComponentDuringLoad", True)
  Call oNVM.Add("SaveLocationIndex", 1)
  Call oNVM.Add("ComponentDestFolder", "C:\Users\adamnagy\Documents\Inventor\SW\")
  Call oNVM.Add("SaveAssemSeperateFolder", False)
  
  Dim oDoc As Document
  Call oTA.Open(oDM, oTC, oNVM, oDoc)
End Sub

Sub PrintInfo(v As Variant, indent As Integer)
  If TypeOf v Is NameValueMap Then
    Dim nvm As NameValueMap
    Set nvm = v
    Dim i As Integer
    For i = 1 To nvm.Count
      Debug.Print Tab(indent); nvm.Name(i)
      Call PrintInfo(nvm.Value(nvm.Name(i)), indent + 1)
    Next
  Else
    Debug.Print Tab(indent); v
  End If
End Sub

Result:

 

Copy occurrences with constraints

By Adam Nagy

In the UI it's quite straight-forward to copy occurrences: just select the components in the UI, do Ctrl+C, then click inside the Model View to make sure it has the focus, then click Ctrl+V. This copy/paste will keep the constraints between the copied occurrences in tact. 

This functionality is not exposed in the API, but you can still use the built-in copy/paste commands to automate things. The other options would be to programmatically copy the occurrences and then recreate the constraints between them yourself, which would be more cumbersome.

Here is a VBA sample code which can do the copying:

Private Declare PtrSafe Function WinAPISetFocus Lib "user32" _
                Alias "SetFocus" (ByVal hwnd As LongPtr) As Long

Sub CopyOccurrencesWithConstraints()
  Dim doc As AssemblyDocument
  Set doc = ThisApplication.ActiveDocument
  
  Dim compDef As AssemblyComponentDefinition
  Set compDef = doc.ComponentDefinition
  
  ' Occurrence count originally
  Dim occCount As Integer
  occCount = compDef.Occurrences.Count

  ' Select the occurrences you want to copy
  ' Either in the UI or programmatically
  ' Programmatic way could be e.g.:
  'Dim occ As ComponentOccurrence
  'Set occ = compDef.Occurrences(1)
  'Call doc.SelectSet.Select(occ)
  'Set occ = compDef.Occurrences(2)
  'Call doc.SelectSet.Select(occ)
  
  Dim cmdMgr As CommandManager
  Set cmdMgr = ThisApplication.CommandManager
  
  ' Now copy them using the built-in command
  Dim copyDef As ControlDefinition
  Set copyDef = cmdMgr.ControlDefinitions.Item("AppCopyCmd")
  Call copyDef.Execute
  
  ' ... and paste them
  ' Here we first have to make sure that the
  ' model view has the focus otherwise the paste
  ' command has no effect
  Call WinAPISetFocus(ThisApplication.ActiveView.hwnd)
  
  ' Now execute the built-in Paste command
  Dim pasteDef As ControlDefinition
  Set pasteDef = cmdMgr.ControlDefinitions.Item("AppPasteCmd")
  Call pasteDef.Execute
  
  ' Set the position of the new components using a matrix
  Dim tr As TransientGeometry
  Set tr = ThisApplication.TransientGeometry
  
  Dim mx As Matrix
  Set mx = tr.CreateMatrix()
  Call mx.SetTranslation(tr.CreateVector(10, 10, 10))
  
  Dim i As Integer
  For i = occCount + 1 To compDef.Occurrences.Count
    compDef.Occurrences(i).Transformation = mx
  Next
End Sub

Result of running the code:

 

WPF Window inside an Inventor Add-In

By Adam Nagy

The question could also be: how to use a WPF Window from a Class Library - which is not specific to Inventor programming. However, here is how you can do it.

1) Create an Inventor Add-In - e.g. using the Inventor Add-In template from File >> New >> Project...

2) Add a WPF User Control via Project >> Add New Item...

3) Change the control to a Window in both the *.xaml and *.xaml.cs files  

4) Add a reference to System.Xaml .NET assembly through Project >> Add Reference... 

5) Modify the Window as you wish - add controls to it, etc

6) Add an Inventor command in the StandardAddInServer.Activate function that will show our dialog. If needed you can also use the System.Windows.Interop.WindowInteropHelper for the reason mentioned here: http://adndevblog.typepad.com/manufacturing/2012/06/space-entered-in-a-text-box-of-a-modeless-dialog-causes-command-to-run-again-c.html  

private Inventor.ButtonDefinition m_btnDef;

public void Activate(Inventor.ApplicationAddInSite addInSiteObject, bool firstTime)
{
  // This method is called by Inventor when it loads the addin.
  // The AddInSiteObject provides access to the Inventor Application object.
  // The FirstTime flag indicates if the addin is loaded for the first time.

  // Initialize AddIn members.
  m_inventorApplication = addInSiteObject.Application;

  // TODO: Add ApplicationAddInServer.Activate implementation.
  // e.g. event initialization, command creation etc.
  var cmdMgr = m_inventorApplication.CommandManager;
  m_btnDef = cmdMgr.ControlDefinitions.AddButtonDefinition(
    "ShowWpfDialog", "ShowWpfDialog", CommandTypesEnum.kQueryOnlyCmdType);
  m_btnDef.OnExecute += ctrlDef_OnExecute;
  m_btnDef.AutoAddToGUI(); 
}

void ctrlDef_OnExecute(NameValueMap Context)
{
  var wpfWindow = new InvAddIn.MyWpfWindow();

  // Could be a good idea to set the owner for this window
  // especially if used as modeless
  var helper = new WindowInteropHelper(wpfWindow);
  helper.Owner = new IntPtr(m_inventorApplication.MainFrameHWND);

  wpfWindow.ShowDialog(); 
}

The command in action

The source code of the sample project: 
https://github.com/adamenagy/Inventor-AddInWithWPF

Pass parameters to a VBA macro from an iLogic Rule

By Adam Nagy

Though RunMacro functionality is only listed in the iLogic function browser tree without the argument parameters: RunMacro(projectName, moduleName, macroName) 

... it seems it can be used this way too: RunMacro(projectName, moduleName, macroName, argument1, argument2, etc) - in which case argument1, argument2, etc. will passed as the VBA macro's input parameters in the same order.

It was discussed in this forum thread: 
https://forums.autodesk.com/t5/inventor-general-discussion/ilogic/td-p/2611136

So you could have an iLogic Rule calling a VBA macro with parameters like this: 

InventorVb.RunMacro(
  "ApplicationProject", ' projectName
  "Module1",               ' moduleName 
  "MyMacro",              ' macroName
  "Hello again!")         ' the first argument we pass to the VBA macro

The above would call a VBA macro from e.g. ApplicationProject >> Module1 

Sub MyMacro(argument1 As String)
  Call MsgBox(argument1) ' >> would pop up with "Hello again!" 
End Sub

Read / Write embedded file

By Adam Nagy

When reading e.g. an embedded Excel file then you can simply use the Excel API to interact with the document. However, if it's e.g. a text file then the default text editor application will be brought up (usually Notepad) and you have no programmatic access to the text file content.

1) The easiest solution would probably be to use a linked text file instead of an embedded one, but it might not be an option.

2) Since Inventor documents are using Structured Storage you might be able to use that API to access the text file. I found this info which could be useful for this. There is also a cool program that enables you to see what's inside the documents called Structured Storage Viewer and this is what a document would look like in it - highlighted in red is the content of the embedded text file:

One issue I found though is that the embedded object's name that you find in the Inventor Model Browser might not be in sync with the name used inside the Structured Storage.

We also have this article on using Structured Storage to store information in Inventor documents, which could also come handy.

A colleague also pointed out this article about using this API from .NET: http://www.developerfusion.com/article/84406/com-structured-storage-from-net/ and this project: http://sourceforge.net/projects/openmcdf/

3) Another option is to hook into the edit mechanism of the embedded file. We'll register our program in the registry as the editor for txt files so that will be called with the path of the temporary txt file that Inventor creates when the document with the embedded text file is opened. Then we edit the file, and when our program exits the modified txt file content will be stored in the Inventor document. I checked and if I modified the txt file after my app closed, then those changes did not get saved into the Inventor document.

For this solution I created a sample project that can be used to modify an embedded text file programmatically: https://github.com/adamenagy/Inventor-ReadWriteEmbeddedFile

Once the program is compiled you can use it like this from VBA:

Sub ModifyEmbeddedTextFile()
  Dim doc As PartDocument
  Set doc = ThisApplication.ActiveDocument

  ' Before running this code the embedded text file
  ' needs to be selected in the Inventor Model Browser 
  Dim obj As ReferencedOLEFileDescriptor
  Set obj = doc.SelectSet(1)

  ' Register our reader for text files
  Call Shell( _
    """" & _
    "C:\Temp\TextReaderCS.exe" & _
    """ """ & _
    "/r" & _
    """", vbNormalFocus)

  ' Get the embedded object opened
  ' Note: this will use the temporary file with
  ' the content of the embedded object
  ' the path of which will be passed to the editor
  ' program
  Call obj.Activate(kShowOLEVerb, Nothing)

  ' Unregister our editor for text files
  Call Shell( _
    """" & _
    "C:\Temp\TextReaderCS.exe" & _
    """ """ & _
    "/u" & _
    """", vbNormalFocus)
End Sub

4) If you just want to read the file then maybe you could just have a File System monitor checking any new file creation in the temp folder, so when Inventor creates the temp files for the embedded files during the opening of the Inventor document then you could be notified about that and could store their paths and read them if needed: System.IO.FileSystemWatcher

If you have multiple embedded documents then it might not be easy to figure out which temp file is for which one.

Texture rotation in the Inventor API

by Vladimir Ananyev

Q: How can I access the rotation and scale data of the texture?

All these values are stored in the appearance asset in the Inventor document.  An asset is a collection of values of different types. They can be simple types like floats, integers, strings, and Booleans, but they can also be more complex types like color, filename, reference to other assets, textures, and choices. In this case we need to find texture and access its values.

The following VBA sample prints all values stored in the AssetTexture object from the active Appearance object.

Sub AssetTextureSample()

    Dim oDoc As PartDocument

    Set oDoc = ThisApplication.ActiveDocument

    Dim oAppearance As Asset

    Set oAppearance = oDoc.ActiveAppearance

 

    Dim oValue As AssetValue

    For Each oValue In oAppearance

 

        If oValue.ValueType = AssetValueTypeEnum.kAssetValueTextureType Then

 

            Dim oTextureAssetValue As TextureAssetValue

            Set oTextureAssetValue = oValue

            Dim oTexture As AssetTexture

            Set oTexture = oTextureAssetValue.value

 

            If oTexture.Item("unifiedbitmap_Bitmap").value <> "" Then

                Debug.Print "---------------------------"

                Debug.Print oAppearance.DisplayName

                Debug.Print "---------------------------"

                Dim v As Variant

                For Each v In oTextureAssetValue.value

                    Debug.Print v.name, v.value

                Next

                Debug.Print "---------------------------" & vbNewLine

            End If

           

        End If  'texture

    Next   'AssetValue

 

    Beep

End Sub

Output:

---------------------------

Birch - Natural Polished

---------------------------

AssetLibID    AFEFC330-5E61-4E24-814F-AE810148B79D

ExchangeGUID 

common_Shared_Asset         common_shared

common_Tint_color            50383104

common_Tint_toggle          False

texture_LinkTextureTransforms             False

texture_MapChannel           1

texture_MapChannel_ID_Advanced             1

texture_MapChannel_UVWSource_Advanced      0

texture_OffsetLock          False

texture_RealWorldOffsetX     0

texture_RealWorldOffsetY     0

texture_RealWorldScaleX      10

texture_RealWorldScaleY      10

texture_ScaleLock           True

texture_UOffset              0

texture_URepeat             True

texture_UScale               1

texture_UVScale              1

texture_VOffset              0

texture_VRepeat             True

texture_VScale               1

texture_WAngle               0

unifiedbitmap_Bitmap        1/Mats/Woods & Plastics.Finish Carpentry.Wood.Red Birch.png

unifiedbitmap_Blur           0,01

unifiedbitmap_Blur_Offset    0

unifiedbitmap_Filtering      0

unifiedbitmap_Invert        False

unifiedbitmap_RGBAmount      1

---------------------------

Highlighted members are responsible for the texture rotate angle (texture_Wangle) and scale (texture_RealWorldScaleX and texture_RealWorldScaleY).  Adding the lines below to the VBA sample you may get the current angle and scale data in more convenient format: 

If oTexture.Item("unifiedbitmap_Bitmap").value <> "" Then

    Debug.Print "---------------------------"

    Debug.Print oAppearance.DisplayName

    Debug.Print "---------------------------"

    Debug.Print "    unified bitmap path:  ", _

        oTexture.Item("unifiedbitmap_Bitmap").value

    Debug.Print "    Rotation angle,deg (texture_WAngle): " _

        & oTexture.Item("texture_WAngle").value

    Debug.Print "    X Size    (texture_RealWorldScaleX): " _

        & oTexture.Item("texture_RealWorldScaleX").value & "  " _

        & oTexture.Item("texture_RealWorldScaleX").Units

    Debug.Print "    Y Size    (texture_RealWorldScaleY): " _

        & oTexture.Item("texture_RealWorldScaleY").value & "  " _

        & oTexture.Item("texture_RealWorldScaleY").Units

    Debug.Print "---------------------------" & vbNewLine

End If

Output:

---------------------------

Birch - Natural Polished

    unified bitmap path:    1/Mats/Woods & Plastics.Finish Carpentry.Wood.Red Birch.png

    Rotation angle,deg (texture_WAngle): 30

    X Size    (texture_RealWorldScaleX): 10  Inch

    Y Size    (texture_RealWorldScaleY): 10  Inch

---------------------------

Note: Rotation angle is represented in degrees in the range 0° – 360°.

Rotation and scale properties are read and write, so we may change them.  Attached part document (Inventor 2016 format) contains the iLogic rule that rotates the active texture according the current value on the slider in the iLogic form:

Here is the iLogic code:

' this iLogic rule rotates the active texture in the range 0° - 360°

' User parameter TextureAngle is controlled by the slider on the iLogic form

DimoDocAsPartDocument = ThisDoc.Document

DimoAppearanceAsAsset = oDoc.ActiveAppearance

DimoValueAsAssetValue

ForEachoValueInoAppearance

    IfoValue.ValueType = AssetValueTypeEnum.kAssetValueTextureTypeThen

        DimoTextureAssetValueAsTextureAssetValue = oValue

        DimoTextureAsAssetTexture = oTextureAssetValue.Value

        IfoTexture.Item("unifiedbitmap_Bitmap").Value <> ""Then

              oTexture.Item("texture_WAngle").Value = TextureAngle

        EndIf

    EndIf

Next

 

Download TestPlate

 

Please refer “Materials and Appearances” overview in the Inventor API Help for additional information on this topic.

Convert VBA to .NET / iLogic

By Adam Nagy

Most of the sample code I publish is in VBA because that is by far the best place to test things out: it's part of Inventor, it has intelli-sense, lets you step through code, you can place break points, use Watches window to check variable values, see all the objects and their functions and properties in the Object Browser, etc. 

When you try to convert VBA code to .NET / iLogic then the 2 main things you need to be aware of are these. I'll show them through trying to run this VBA code from an iLogic rule:

Sub MySubMethod()
  Dim doc As Document
  Set doc = ThisApplication.ActiveDocument
  
  Call MsgBox(doc.DisplayName)
End Sub

Sub MyMainMethod()
  ' Do something
  
  ' Then call another method
  Call MySubMethod
End Sub

1) Main function needs to be the first

If you have multiple methods then the first one should be the one where the whole code execution starts and should be named Sub Main(). In case of my sample I need to move Sub MyMainMethod() to the top of the code and rename it to Sub Main(). 

2) No Let/Set

You simply have to delete the "Set" keywords from your code

The final iLogic code:

Sub Main()
  ' Do something
  
  ' Then call another method
  Call MySubMethod
End Sub

Sub MySubMethod()
  Dim doc As Document
  doc = ThisApplication.ActiveDocument

  Call MsgBox(doc.DisplayName)
End Sub

One more thing which is not necessary but I think worth changing is moving from On Error Resume Next to Try/Catch. So instead of doing this:  

On Error Resume Next
Dim doc As PartDocument
doc = ThisApplication.ActiveDocument
If Err.Number = 0 Then
  Call MsgBox(doc.DisplayName)
Else
  Call MsgBox("No active part document")
End If
On Error Goto 0

... you would do this:

Dim doc As PartDocument
Try
  doc = ThisApplication.ActiveDocument
  Call MsgBox(doc.DisplayName)
Catch
  Call MsgBox("No active part document")
End Try