/// <summary>
/// Serializes the parameters of the macro feature to a structure
/// </summary>
/// <typeparam name="TParams">Type of parameters structure</typeparam>
/// <param name="featData">Pointer to macro feature data</param>
/// <param name="feat">Pointer to a feature</param>
/// <param name="model">Pointer to model document</param>
/// <param name="parameters">Parameters to serialize</param>
public static void SetParameters <TParams>(this IMacroFeatureData featData, IFeature feat, IModelDoc2 model, TParams parameters)
where TParams : class, new()
{
MacroFeatureOutdateState_e state;
m_ParamsParser.SetParameters(model, feat, featData, parameters, out state);
}
/// <summary>
/// Parameters are not updated when SetParameters is called from OnRebuild method, updating one by one fixes the issue
/// </summary>
private void UpdateParameters(IMacroFeatureData featData,
string[] paramNames, int[] paramTypes, string[] paramValues)
{
if (paramNames != null && paramTypes != null && paramValues != null)
{
for (int i = 0; i < paramNames.Length; i++)
{
var paramName = paramNames[i];
var val = paramValues[i];
switch ((swMacroFeatureParamType_e)paramTypes[i])
{
case swMacroFeatureParamType_e.swMacroFeatureParamTypeString:
featData.SetStringByName(paramName, val);
break;
case swMacroFeatureParamType_e.swMacroFeatureParamTypeInteger:
featData.SetIntegerByName(paramName, int.Parse(val));
break;
case swMacroFeatureParamType_e.swMacroFeatureParamTypeDouble:
featData.SetDoubleByName(paramName, double.Parse(val));
break;
}
}
}
}
/// <summary>
/// Json反序列化
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="macroFeatureData"></param>
/// <returns></returns>
public static T Read <T>(this IMacroFeatureData macroFeatureData)
{
string data;
macroFeatureData.GetStringByName(FeatureDataKey, out data);
return(JsonConvert.DeserializeObject <T>(data));
}
/// <summary>
/// Adds tracking ids to a body faces and edges. This is not the best way to
/// do this in a repeatable way but works quickly.
/// </summary>
/// <param name="macroFeatureData"></param>
/// <param name="body"></param>
public static int AddIdsToBody(this IMacroFeatureData macroFeatureData, IBody2 body, int i = 1)
{
if (body == null)
{
throw new ArgumentNullException(nameof(body));
}
{
object FacesNeedId;
object EdgesNeedId;
macroFeatureData.GetEntitiesNeedUserId((object)body, out FacesNeedId, out EdgesNeedId);
var edgesNeedId = (object[])EdgesNeedId;
var facesNeedId = (object[])FacesNeedId;
var empty = new object[] {};
foreach (var edge in edgesNeedId ?? empty)
{
if (!macroFeatureData.SetEdgeUserId((Edge)edge, i, 0))
{
throw new Exception("SetUserIdFailed");
}
i++;
}
foreach (var face in facesNeedId ?? empty)
{
if (!macroFeatureData.SetFaceUserId((Face2)face, i, 0))
{
throw new Exception("SetUserIdFailed");
}
i++;
}
}
return(i);
}
public static T Read <T>(this IMacroFeatureData macroFeatureData)
{
string data;
macroFeatureData.GetStringByName(FeatureDataKey, out data);
return(Json.FromJson <T>(data));
}
internal TParams GetParameters <TParams>(IFeature feat, IMacroFeatureData featData, IModelDoc2 model,
out IDisplayDimension[] dispDims, out string[] dispDimParams, out IBody2[] editBodies, out MacroFeatureOutdateState_e state)
where TParams : class, new()
{
return(GetParameters(feat, featData, model, typeof(TParams), out dispDims,
out dispDimParams, out editBodies, out state) as TParams);
}
/// <summary>
/// 获取选中对象,通过类型和标记
/// Return selected objects filtered by type and mark.
/// </summary>
/// <param name="selMgr"></param>
/// <param name="filter">(type,mark)=>bool</param>
/// <returns></returns>
public static IEnumerable <object> GetSelectedObjects(this IMacroFeatureData selMgr, Func <swSelectType_e, int, bool> filter)
{
{
object objects;
object objectTypes;
object marks;
object drViews;
object componentXForms;
selMgr.GetSelections3(out objects, out objectTypes, out marks, out drViews, out componentXForms);
var objectsArray = (object[])objects;
var typesArray = (swSelectType_e[])objectTypes;
var marksArray = (int[])marks;
var i = 0;
foreach (var item in objectsArray)
{
if (filter(typesArray[i], marksArray[i]))
{
yield return(item);
}
i++;
}
}
}
public void ShowPage(RoundStockFeatureParameters parameters, IPartDoc part, IFeature editingFeature, IMacroFeatureData featData)
{
m_CurrentParameters = parameters;
m_CurrentPart = part;
m_EditingFeature = editingFeature;
m_EditingFeatureData = featData;
if (m_ActivePage != null)
{
m_ActivePage.Handler.DataChanged -= OnDataChanged;
m_ActivePage.Handler.Closing -= OnPageClosing;
m_ActivePage.Handler.Closed -= OnClosed;
}
m_CurrentViewModel = RoundStockViewModel.FromParameters(parameters);
m_ActivePage = new RoundStockView(m_CurrentViewModel, m_App);
m_ActivePage.Handler.DataChanged += OnDataChanged;
m_ActivePage.Handler.Closing += OnPageClosing;
m_ActivePage.Handler.Closed += OnClosed;
m_ActivePage.Show();
m_Model.ShowPreview(part, parameters.Direction, parameters.ConcenticWithCylindricalFace,
parameters.StockStep, parameters.ExtraRadius);
}
private void OnFeatureEditingCompleted(RoundStockFeatureParameters parameters,
IPartDoc part, IFeature feat, IMacroFeatureData featData, bool isOk)
{
if (isOk)
{
MacroFeatureOutdateState_e state;
SetParameters(part as IModelDoc2, feat, featData, parameters, out state);
if (state != MacroFeatureOutdateState_e.UpToDate)
{
if (m_Controller.App.SendMsgToUser2("This features is outdated. It is required to replace it. Do you want to replace this feature?",
(int)swMessageBoxIcon_e.swMbWarning,
(int)swMessageBoxBtn_e.swMbYesNo) == (int)swMessageBoxResult_e.swMbHitYes)
{
feat = (part as IModelDoc2).FeatureManager
.ReplaceComFeature <RoundStockMacroFeature, RoundStockFeatureParameters>(
feat, parameters);
return;
}
}
feat.ModifyDefinition(featData, part, null);
}
else
{
featData.ReleaseSelectionAccess();
}
}
/// <summary>
/// Returns the current instance of parameters data model for the feature
/// </summary>
/// <param name="feat">Pointer to feature</param>
/// <param name="featData">Pointer to feature data</param>
/// <param name="model">Pointer to model</param>
/// <returns>Current instance of parameters</returns>
protected TParams GetParameters(IFeature feat, IMacroFeatureData featData, IModelDoc2 model)
{
IDisplayDimension[] dispDims;
IBody2[] editBodies;
var parameters = GetParameters(feat, featData, model, out dispDims, out editBodies);
return(parameters);
}
private object GetBodyResult(ISldWorks app, IEnumerable <IBody2> bodies, IMacroFeatureData featData, bool updateEntityIds)
{
if (bodies != null)
{
if (CompatibilityUtils.IsVersionNewerOrEqual(app, SwVersion_e.Sw2013, 5))
{
featData.EnableMultiBodyConsume = true;
}
if (updateEntityIds)
{
if (featData == null)
{
throw new ArgumentNullException(nameof(featData));
}
foreach (var body in bodies)
{
object faces;
object edges;
featData.GetEntitiesNeedUserId(body, out faces, out edges);
if (faces is object[])
{
int nextId = 0;
foreach (Face2 face in faces as object[])
{
featData.SetFaceUserId(face, nextId++, 0);
}
}
if (edges is object[])
{
int nextId = 0;
foreach (Edge edge in edges as object[])
{
featData.SetEdgeUserId(edge, nextId++, 0);
}
}
}
}
if (bodies.Count() == 1)
{
return(bodies.First());
}
else
{
return(bodies.ToArray());
}
}
else
{
throw new ArgumentNullException(nameof(bodies));
}
}
protected TParams GetParameters(IFeature feat, IMacroFeatureData featData, IModelDoc2 model,
out IDisplayDimension[] dispDims, out IBody2[] editBodies)
{
MacroFeatureOutdateState_e state;
string[] dispDimParams;
return(m_ParamsParser.GetParameters <TParams>(feat, featData, model, out dispDims,
out dispDimParams, out editBodies, out state));
}
internal void Show(IModelDoc2 model, IFeature feat, IMacroFeatureData featData, TPage data)
{
m_Model = model;
m_Data = data;
m_Feat = feat;
m_FeatData = featData;
m_Page.Show(data);
}
/// <summary>
/// Deserializes the parameters of the macro feature to a structure
/// </summary>
/// <typeparam name="TParams">Type of parameters structure</typeparam>
/// <param name="featData">Pointer to macro feature data</param>
/// <param name="feat">Pointer to a feature</param>
/// <param name="model">Pointer to model document</param>
/// <returns>Parameters</returns>
public static TParams GetParameters <TParams>(this IMacroFeatureData featData, IFeature feat, IModelDoc2 model)
where TParams : class, new()
{
IDisplayDimension[] dispDims;
IBody2[] bodies;
MacroFeatureOutdateState_e state;
string[] dispDimParams;
return(m_ParamsParser.GetParameters <TParams>(feat, featData, model,
out dispDims, out dispDimParams, out bodies, out state));
}
private Version GetVersion(IMacroFeatureData featData, string name)
{
Version dimsVersion;
string versVal;
featData.GetStringByName(name, out versVal);
if (!Version.TryParse(versVal, out dimsVersion))
{
dimsVersion = new Version();
}
return(dimsVersion);
}
private void OnFeatureEditCompleted(IModelDoc2 model, IFeature feat, IMacroFeatureData featData, TPage data, bool isOk)
{
HidePreview(model, m_CurrentEditBodies.ToArray());
if (isOk)
{
var parameters = ConvertPageToParams(data);
SetParameters(model, feat, featData, parameters);
feat.ModifyDefinition(featData, model, null);
}
else
{
featData.ReleaseSelectionAccess();
}
}
private void ShowPropertyPage(ISldWorks app, IModelDoc2 model, IFeature feat,
IMacroFeatureData featData, TParams parameters, PageClosedDelegate <TPage> closeHandler)
{
m_CurrentEditBodies = new List <IBody2>();
m_CurrentPreviewBodies = new List <IBody2>();
m_LastError = null;
m_CurrentCloseHandler = closeHandler;
var data = ConvertParamsToPage(parameters);
GetPage(app).Show(model, feat, featData, data);
PregenerateAndPreviewGeometry(app, model, parameters);
}
internal protected MacroFeatureRebuildBodyResult(IMacroFeatureData featData,
bool updateEntityIds, params IBody2[] bodies) : base(GetBodyResult(bodies))
{
if (Context.CurrentApp.IsVersionNewerOrEqual(SwVersion_e.Sw2013, 5))
{
featData.EnableMultiBodyConsume = true;
}
if (updateEntityIds)
{
if (featData == null)
{
throw new ArgumentNullException(nameof(featData));
}
for (int i = 0; i < bodies.Length; i++)
{
var body = bodies[i];
object faces;
object edges;
featData.GetEntitiesNeedUserId(body, out faces, out edges);
if (faces is object[])
{
int nextId = 0;
foreach (Face2 face in faces as object[])
{
featData.SetFaceUserId(face, nextId++, 0);
}
}
if (edges is object[])
{
int nextId = 0;
foreach (Edge edge in edges as object[])
{
featData.SetEdgeUserId(edge, nextId++, 0);
}
}
}
}
}
private void OnFeatureInsertCompleted(IModelDoc2 model, IFeature feat, IMacroFeatureData featData, TPage data, bool isOk)
{
Logger.Log("Inserting new feature");
HidePreview(model, m_CurrentEditBodies.ToArray());
if (isOk)
{
try
{
var parameters = ConvertPageToParams(data);
var newFeat = model.FeatureManager.InsertComFeature(GetType(), parameters);
}
catch (Exception ex)
{
Logger.Log(ex);
throw;
}
}
}
private MacroFeatureOutdateState_e GetState(IMacroFeatureData featData, IDisplayDimension[] dispDims)
{
var state = MacroFeatureOutdateState_e.UpToDate;
if (dispDims != null && dispDims.Any(d => d is DisplayDimensionPlaceholder))
{
state |= MacroFeatureOutdateState_e.Dimensions;
}
if (m_CurrentIcons != null)
{
var curIcons = featData.IconFiles as string[];
if (curIcons == null || !m_CurrentIcons.SequenceEqual(curIcons,
StringComparer.CurrentCultureIgnoreCase))
{
state |= MacroFeatureOutdateState_e.Icons;
}
}
return(state);
}
protected override MacroFeatureRebuildResult CreateRebuildResult(ISldWorks app, IMacroFeatureData featData, BodiesFilletFeatureDataModel parameters)
{
IReadOnlyList <IFace2> filletFaces;
var bodies = CreateFillets(app, parameters.Selections, parameters.Radius, false, out filletFaces);
return(new BodiesFilletMacroFeatureRebuildResult(featData, bodies, filletFaces));
}
internal BodiesFilletMacroFeatureRebuildResult(IMacroFeatureData featData,
IBody2[] bodies, IReadOnlyList <IFace2> filletFaces) : base(featData, true, bodies)
{
FilletFaces = filletFaces;
}
private object ParseMacroFeatureResult(CustomFeatureRebuildResult res, ISldWorks app, IMacroFeatureData featData)
{
switch (res)
{
case CustomFeatureBodyRebuildResult bodyRes:
//TODO: validate if any non SwBody in the array
//TODO: get updateEntityIds from the parameters
return(GetBodyResult(app, bodyRes.Bodies?.OfType <SwBody>().Select(b => b.Body), featData, true));
default:
return(GetStatusResult(res.Result, res.ErrorMessage));
}
}
/// <summary>
/// 将数据序列化到宏特征上
/// </summary>
/// <param name="macroFeatureData"></param>
/// <param name="data"></param>
public static void Write(this IMacroFeatureData macroFeatureData, object data)
{
macroFeatureData.SetStringByName(FeatureDataKey, JsonConvert.SerializeObject(data));
}
public static void Write(this IMacroFeatureData macroFeatureData, object data)
{
macroFeatureData.SetStringByName(FeatureDataKey, Json.ToJson(data));
}
private object GetBodyResult(ISldWorks app, IModelDoc2 model, IEnumerable <IBody2> bodies,
IMacroFeatureData featData, bool updateEntityIds)
{
if (bodies != null)
{
if (CompatibilityUtils.IsVersionNewerOrEqual(app, SwVersion_e.Sw2013, 5))
{
featData.EnableMultiBodyConsume = true;
}
if (updateEntityIds)
{
if (featData == null)
{
throw new ArgumentNullException(nameof(featData));
}
foreach (var body in bodies)
{
object faces;
object edges;
featData.GetEntitiesNeedUserId(body, out faces, out edges);
if (faces is object[])
{
var faceIds = (faces as object[]).ToDictionary(x => (Face2)x, x => new MacroFeatureEntityId());
AssignFaceIds(app, model, faceIds);
foreach (var faceId in faceIds)
{
featData.SetFaceUserId(faceId.Key, faceId.Value.FirstId, faceId.Value.SecondId);
}
}
if (edges is object[])
{
var edgeIds = (edges as object[]).ToDictionary(x => (Edge)x, x => new MacroFeatureEntityId());
AssignEdgeIds(app, model, edgeIds);
foreach (var edgeId in edgeIds)
{
featData.SetEdgeUserId(edgeId.Key, edgeId.Value.FirstId, edgeId.Value.SecondId);
}
}
}
}
if (bodies.Count() == 1)
{
return(bodies.First());
}
else
{
return(bodies.ToArray());
}
}
else
{
throw new ArgumentNullException(nameof(bodies));
}
}
/// <inheritdoc cref="SetParameters(IModelDoc2, IFeature, IMacroFeatureData, TParams)"/>
/// <param name="state">Current state of the parameters</param>
protected void SetParameters(IModelDoc2 model, IFeature feat, IMacroFeatureData featData, TParams parameters, out MacroFeatureOutdateState_e state)
{
m_ParamsParser.SetParameters(model, feat, featData, parameters, out state);
}
protected virtual MacroFeatureRebuildResult CreateRebuildResult(ISldWorks app, IMacroFeatureData featData, TParams parameters)
{
var bodies = CreateGeometry(app, parameters);
if (bodies.Any())
{
return(MacroFeatureRebuildResult.FromBodies(bodies, featData, true));
}
else
{
return(MacroFeatureRebuildResult.FromStatus(true));
}
}
private void OnPageClosed(IModelDoc2 model, IFeature feat, IMacroFeatureData featData, TPage data, bool isOk)
{
m_CurrentCloseHandler?.Invoke(model, feat, featData, data, isOk);
}
public IMacroFeatureDataObject(IMacroFeatureData IMacroFeatureDatainstance)
{
IMacroFeatureDataInstance = IMacroFeatureDatainstance;
}
