SOLIDWORKS API: Copying a Face with Move Face — Working Around the InsertMoveFace3 Translate-Copy Gap

The Move Face command in SOLIDWORKS has three modes: Offset, Translate, and Rotate. In Translate mode, the PropertyManager shows a Copy checkbox. When checked, the original face stays in place and a translated copy is created alongside it — useful for generating offset geometry, creating clearance ledges, or duplicating a surface patch to use as a reference.

The API tells a different story.

IFeatureManager.InsertMoveFace3 is the method that drives Move Face programmatically. Its signature accepts a move type from swMoveFaceType_e (0 = Translate, 1 = Rotate, 2 = Offset), the faces to move, and the transformation values. There is no copy parameter. IMoveFaceFeatureData, the data accessor for reading back a Move Face feature, has properties for MoveType, Distance, Rotation, TranslationX/Y/Z, and the face arrays — but no Copy or bCopy flag anywhere in the interface.

This is a genuine API gap confirmed by the SOLIDWORKS forum and reproducible in any release through 2026. If you call InsertMoveFace3 with swMoveFaceTypeTranslate, the original face moves. There is no overload that produces a copy. The Copy checkbox in the UI does not correspond to any exposed API parameter.

What the UI Copy Mode Actually Does

Decompiling the SOLIDWORKS application and watching the feature tree after a Translate+Copy operation reveals what happens internally: the operation inserts two features — a surface offset of the original face(s) at zero distance (creating a surface body copy), followed by a translate operation on that surface body. The result is presented as a single Move Face feature in the UI tree, but the underlying geometry pipeline is a two-step process.

This explains why the API doesn’t expose it as a parameter: it is not a single atomic operation at the geometry kernel level. It is a composed operation that the UI abstracts into one step.

Three Workarounds

Option 1: Surface Offset at Zero Distance

The most direct approach. Pre-select the faces you want to copy, then call InsertOffsetSurface with a distance of 0:

' VBA — select face first, then run
Dim swModel As SldWorks.ModelDoc2
Dim swFeatMgr As SldWorks.FeatureManager

Set swModel = Application.SldWorks.ActiveDoc
Set swFeatMgr = swModel.FeatureManager

' Assumes target face is already selected
swModel.InsertOffsetSurface 0#, False

' Now you have a surface body copy of the face
' Translate it as a surface body
Dim swSelMgr As SldWorks.SelectionMgr
Set swSelMgr = swModel.SelectionManager

' Get the surface body just created
Dim swFeat As SldWorks.Feature
Set swFeat = swModel.Extension.GetLastFeatureAdded

' Select the surface body, then move it
' (surface body selection requires GetFirstBody/GetNextBody iteration)

This produces a surface feature, not a solid face modification. If your goal is a solid result, you need a subsequent step — typically knitting the surface back onto a solid using InsertKnitSurface, or using the surface as a trim tool.

The surface offset at zero works reliably for planar, cylindrical, and B-spline faces. It inherits the exact geometry of the original face without any interpolation.

Option 2: IBody2.Copy + Transform

For cases where you need the copy as a manipulable body object rather than a feature tree entry, IBody2.Copy returns an independent body with identical geometry that you can transform in memory:

' VBA — get a body copy and transform it
Dim swModel As SldWorks.ModelDoc2
Set swModel = Application.SldWorks.ActiveDoc

Dim swPart As SldWorks.PartDoc
Set swPart = swModel

' Get the first body (adjust if multi-body part)
Dim swBodies As Variant
swBodies = swPart.GetBodies2(swSolidBody, True)

Dim srcBody As SldWorks.Body2
Set srcBody = swBodies(0)

' Copy the body — returns an independent Body2
Dim copyBody As SldWorks.Body2
Set copyBody = srcBody.Copy

' Build a translation transform (10mm in X)
Dim swMath As SldWorks.MathUtility
Set swMath = Application.SldWorks.GetMathUtility

Dim dData(15) As Double
dData(0) = 1 : dData(1) = 0 : dData(2) = 0   ' X axis
dData(3) = 0 : dData(4) = 1 : dData(5) = 0   ' Y axis  
dData(6) = 0 : dData(7) = 0 : dData(8) = 1   ' Z axis
dData(9) = 0.01 : dData(10) = 0 : dData(11) = 0  ' Translation in meters (10mm)
dData(12) = 1 : dData(13) = 0 : dData(14) = 0
dData(15) = 0

Dim swXform As SldWorks.MathTransform
Set swXform = swMath.CreateTransform(dData)

' Apply transform to the copied body
copyBody.ApplyTransform swXform

' The copied body now exists in memory but is not in the feature tree
' To insert it as a feature, use CreateBodyFromBodies or similar

The in-memory body approach is useful when you need to perform Boolean operations or geometry queries on the copy before deciding whether to insert it as a feature. The SOLIDWORKS API’s IBody2 has a complete geometry API for bounding box queries, ray intersection, face iteration, and point projection — all of which work on in-memory bodies without any feature tree involvement.

One limitation: IBody2.Copy copies the entire body, including all faces. If you only want a copy of a specific face from a body that has many faces, you need to extract that face’s underlying surface using IFace2.GetSurface() and ISurface.CreateTrimmedSurface2() before copying.

Option 3: Knit Surface from Selected Faces

For the specific case where you want to copy one or more faces from a solid and produce a standalone surface feature from those faces (the closest true equivalent to the UI Copy behavior), the combination of IFace2 surface extraction and InsertKnitSurface gives you a parametric feature tree entry:

' VBA — copy selected faces as a surface feature
' Assumes faces are pre-selected (same selection as Move Face UI)
Dim swModel As SldWorks.ModelDoc2
Set swModel = Application.SldWorks.ActiveDoc

' InsertOffsetSurface at 0 creates a Offset Surface feature
' from the currently selected faces — exact copy, zero offset
Dim bRev As Boolean
bRev = False  ' Normal direction
swModel.InsertOffsetSurface 0.0, bRev

' Rename for clarity
Dim lastFeat As SldWorks.Feature
Set lastFeat = swModel.Extension.GetLastFeatureAdded
lastFeat.Name = "Face Copy"

' Now translate the surface body using InsertMoveCopyBody2
' Select the surface body first...
' InsertMoveCopyBody2(NumParam, bCopy, nMove, Params())
' For translate: nMove = swMoveCopyBodyTranslate (2)
' Params: X, Y, Z translation in meters
Dim dParams(2) As Double
dParams(0) = 0.01  ' 10mm X
dParams(1) = 0.0
dParams(2) = 0.0

' Note: body must be selected before this call
swModel.FeatureManager.InsertMoveCopyBody2 3, False, 2, dParams

Note the distinction: InsertMoveCopyBody2 (Move/Copy Body) operates on a complete body — it is not restricted to faces. When you use InsertOffsetSurface at zero to create a surface body copy of specific faces, and then call InsertMoveCopyBody2 on that surface body with bCopy = False, you achieve the equivalent of the UI’s Move Face Translate+Copy in two explicit API calls.

Which Approach to Use

The surface offset at zero is the most practical for macro-level automation. The IBody2.Copy route is for add-in code doing geometry processing before committing to features.

The Broader Pattern

This gap is one of several places in the SOLIDWORKS API where the UI operation has no direct parameter equivalent. The macro recorder captures InsertMoveFace3 when you use Translate mode, but it silently drops the Copy checkbox — the same behavior documented for sketch relations, equations, and linear pattern creation covered in the SOLIDWORKS macro recorder limitations guide.

The API was layered incrementally over the SOLIDWORKS geometry kernel. Operations that are atomic in the UI are often composed from multiple lower-level API calls. When Dassault added the Copy option to Translate mode in the UI, they did not add a corresponding parameter to the existing InsertMoveFace3 method — they implemented it internally as a surface extraction followed by a move, and surfaced it only through the PropertyManager.

For teams building export pipelines or geometry analysis tools that need to inspect or replicate the Copy behavior, the surface offset at zero distance approach is the one that maps most cleanly to what the UI actually does under the hood. For automation work involving batch DXF export from flat patterns, the API DXF export guide covers the parallel situation where ExportToDWG2 and the Save As dialog use different internal code paths and produce different output without any documented parameter to control which one runs.