public virtual void SetParameters(IXDocument model, IXCustomFeature feat,
object parameters, out CustomFeatureOutdateState_e state)
{
CustomFeatureParameter[] param;
IXSelObject[] selection;
CustomFeatureDimensionType_e[] dimTypes;
double[] dimValues;
IXBody[] bodies;
Parse(parameters,
out param,
out selection, out dimTypes, out dimValues, out bodies);
var dispDims = GetDimensions(feat);
var dimsVersion = GetDimensionsVersion(feat);
ConvertParameters(parameters.GetType(), dimsVersion, conv =>
{
dispDims = conv.ConvertDisplayDimensions(model, feat, dispDims);
});
if (dispDims != null)
{
if (dispDims.Length != dimValues.Length)
{
throw new ParametersMismatchException("Dimensions mismatch");
}
}
state = GetState(feat, dispDims);
SetParametersToFeature(feat, selection, bodies, dispDims, dimValues, param);
}
protected override void ExtractRawParameters(IXCustomFeature feat, IXDocument doc,
out Dictionary <string, object> parameters,
out IXDimension[] dimensions, out IXSelObject[] selection, out IXBody[] editBodies)
{
object retParamNames = null;
object retParamValues = null;
object paramTypes = null;
object retSelObj;
object selObjType;
object selMarks;
object selDrViews;
object compXforms;
var featData = ((SwMacroFeature)feat).FeatureData;
featData.GetParameters(out retParamNames, out paramTypes, out retParamValues);
featData.GetSelections3(out retSelObj, out selObjType, out selMarks, out selDrViews, out compXforms);
dimensions = GetDimensions(feat);
var editBodiesObj = featData.EditBodies as object[];
if (editBodiesObj != null)
{
editBodies = editBodiesObj.Cast <IBody2>()
.Select(b => SwObject.FromDispatch <SwBody>(b, (SwDocument)doc)).ToArray();
}
else
{
editBodies = null;
}
var paramNames = retParamNames as string[];
var paramValues = retParamValues as string[];
if (paramNames != null)
{
parameters = new Dictionary <string, object>();
for (int i = 0; i < paramNames.Length; i++)
{
parameters.Add(paramNames[i], paramValues[i]);
}
}
else
{
parameters = null;
}
var selObjects = retSelObj as object[];
if (selObjects != null)
{
selection = selObjects.Select(s => SwObject.FromDispatch <SwSelObject>(s, (SwDocument)doc)).ToArray();
}
else
{
selection = null;
}
}
public void Insert(IXDocument model)
{
m_CurData = new TPage();
CurModel = model;
m_EditingFeature = null;
m_PmPage.Show(m_CurData);
}
public void Insert(IXDocument model)
{
m_CurData = new TPage();
CurModel = model;
m_EditingFeature = null;
EditingStarted?.Invoke(m_App, model, null);
m_PmPage.Show(m_CurData);
UpdatePreview();
}
public void Edit(IXDocument model, IXCustomFeature <TData> feature)
{
CurModel = model;
m_EditingFeature = feature;
try
{
var featParam = m_EditingFeature.Parameters;
m_CurData = m_DataToPageConv.Invoke(featParam);
m_PmPage.Show(m_CurData);
UpdatePreview();
}
catch
{
m_EditingFeature.Parameters = null;
}
}
public override object GetParameters(IXCustomFeature feat, IXDocument model, Type paramsType, out IXDimension[] dispDims, out string[] dispDimParams, out IXBody[] editBodies, out IXSelObject[] sels, out CustomFeatureOutdateState_e state)
{
dispDims = null;
try
{
return(base.GetParameters(feat, model, paramsType, out dispDims, out dispDimParams, out editBodies, out sels, out state));
}
catch
{
if (dispDims != null)
{
foreach (SwDimension dim in dispDims)
{
dim.Dispose();
}
}
throw;
}
}
protected override IXDimension[] GetDimensions(IXCustomFeature feat)
{
var dispDimsObj = ((SwMacroFeature)feat).FeatureData.GetDisplayDimensions() as object[];
if (dispDimsObj != null)
{
var dimensions = new IXDimension[dispDimsObj.Length];
for (int i = 0; i < dispDimsObj.Length; i++)
{
dimensions[i] = new SwDimension(dispDimsObj[i] as IDisplayDimension);
dispDimsObj[i] = null;
}
return(dimensions);
}
else
{
return(null);
}
}
public void Edit(IXDocument model, IXCustomFeature <TData> feature)
{
CurModel = model;
m_EditingFeature = feature;
try
{
var featParam = m_EditingFeature.Parameters;
m_CurPageData = Definition.ConvertParamsToPage(featParam);
EditingStarted?.Invoke(m_App, model, feature, featParam, m_CurPageData);
m_PmPage.Show(m_CurPageData);
UpdatePreview();
}
catch
{
m_EditingFeature.Parameters = null;
}
}
public override void OnFeatureInserted(IXApplication app, IXDocument doc, IXCustomFeature <CoordinateSystemData> feat,
CoordinateSystemData data, CoordinateSystemData page)
{
var bodies = ((object[])((ISwDocument)doc).Model.Extension.FindTrackedObjects(m_TrackingId, null,
new int[] { (int)swTopoEntity_e.swTopoBody }, new int[] { X_BODY_TRACKING_ID, Y_BODY_TRACKING_ID, Z_BODY_TRACKING_ID })).Cast <IBody2>().ToArray();
var xBody = bodies[0];
var yBody = bodies[1];
var zBody = bodies[2];
var xEdge = (IEntity)((object[])xBody.GetEdges()).First();
var yEdge = (IEntity)((object[])yBody.GetEdges()).First();
var zEdge = (IEntity)((object[])zBody.GetEdges()).First();
var orig = (IEntity)((IEdge)xEdge).GetStartVertex();
if (xBody.RemoveTrackingID(m_TrackingId) != (int)swTrackingIDError_e.swTrackingIDError_NoError)
{
throw new Exception("Failed to clear track body");
}
if (yBody.RemoveTrackingID(m_TrackingId) != (int)swTrackingIDError_e.swTrackingIDError_NoError)
{
throw new Exception("Failed to clear track body");
}
if (zBody.RemoveTrackingID(m_TrackingId) != (int)swTrackingIDError_e.swTrackingIDError_NoError)
{
throw new Exception("Failed to clear track body");
}
orig.SelectByMark(false, 1);
xEdge.SelectByMark(true, 2);
yEdge.SelectByMark(true, 4);
zEdge.SelectByMark(true, 8);
var coordSysFeat = ((ISwDocument)doc).Model.FeatureManager.InsertCoordinateSystem(false, false, false);
((ISwFeature)feat).Feature.MakeSubFeature(coordSysFeat);
}
protected override CustomFeatureOutdateState_e GetState(IXCustomFeature featData, IXDimension[] dispDims)
{
var state = CustomFeatureOutdateState_e.UpToDate;
if (dispDims != null && dispDims.Any(d => d is SwDimensionPlaceholder))
{
state |= CustomFeatureOutdateState_e.Dimensions;
}
//TODO: fix icons
//if (m_CurrentIcons != null)
//{
// var curIcons = featData.IconFiles as string[];
// if (curIcons == null || !m_CurrentIcons.SequenceEqual(curIcons,
// StringComparer.CurrentCultureIgnoreCase))
// {
// state |= CustomFeatureOutdateState_e.Icons;
// }
//}
return(state);
}
public override void OnEditingStarted(IXApplication app, IXDocument doc, IXCustomFeature <CabinetSizeData> feat,
CabinetSizeData data, CabinetConfiguratorPage page)
{
page.Order.Db = new FurnitureDbContext(Settings.Default.DbConnectionString);
UpdateStatuses(page);
}
protected override void SetParametersToFeature(IXCustomFeature feat, IXSelObject[] selection, IXBody[] editBodies,
IXDimension[] dims, double[] dimValues, CustomFeatureParameter[] param)
{
try
{
var featData = ((SwMacroFeature)feat).FeatureData;
if (selection != null && selection.Any())
{
var dispWraps = selection.Cast <SwSelObject>().Select(s => new DispatchWrapper(s.Dispatch)).ToArray();
featData.SetSelections2(dispWraps, new int[selection.Length], new IView[selection.Length]);
}
if (editBodies != null)
{
featData.EditBodies = editBodies.Cast <SwBody>().Select(b => b.Body).ToArray();
}
if (dims != null)
{
for (int i = 0; i < dims.Length; i++)
{
dims[i].SetValue(dimValues[i]);
((SwDimension)dims[i]).Dispose();
}
}
var state = GetState(feat, dims);
if (param.Any())
{
//macro feature dimensions cannot be changed in the existing feature
//reverting the dimensions version
if (state.HasFlag(CustomFeatureOutdateState_e.Dimensions))
{
var vers = GetVersion(feat, VERSION_DIMENSIONS_NAME);
var par = param.First(p => p.Name == VERSION_DIMENSIONS_NAME);
par.Value = vers.ToString();
}
string[] paramNames;
string[] paramValues;
int[] paramTypes;
ConvertParameters(param, out paramNames, out paramTypes, out paramValues);
featData.SetParameters(paramNames, paramTypes, paramValues);
UpdateParameters(featData, paramNames, paramTypes, paramValues);
}
}
finally
{
if (dims != null)
{
foreach (SwDimension dim in dims)
{
dim.Dispose();
}
}
}
}
public override Dictionary <string, string> ConvertParameters(IXDocument model, IXCustomFeature feat, Dictionary <string, string> parameters)
{
var paramVal = parameters["Param1"];
parameters.Remove("Param1");
parameters.Add("Param1A", paramVal); //renaming parameter
parameters.Add("Param3", "Default"); //adding new parameter with default value
return(parameters);
}
protected abstract IXDimension[] GetDimensions(IXCustomFeature feat);
//TODO: need to spearate to different methods
protected abstract void ExtractRawParameters(IXCustomFeature feat, IXDocument doc,
out Dictionary <string, object> parameters, out IXDimension[] dimensions,
out IXSelObject[] selection, out IXBody[] editBodies);
public virtual IXDimension[] ConvertDisplayDimensions(IXDocument model, IXCustomFeature feat, IXDimension[] dispDims)
{
return(dispDims);
}
public virtual object GetParameters(IXCustomFeature feat, IXDocument model, Type paramsType,
out IXDimension[] dispDims, out string[] dispDimParams, out IXBody[] editBodies,
out IXSelObject[] sels, out CustomFeatureOutdateState_e state)
{
var dispDimParamsMap = new SortedDictionary <int, string>();
Dictionary <string, object> featRawParams;
IXDimension[] featDims;
IXSelObject[] featSels;
IXBody[] featBodies;
ExtractRawParameters(feat, model, out featRawParams, out featDims, out featSels, out featBodies);
var parameters = new Dictionary <string, string>();
var paramsVersion = new Version();
var dimsVersion = new Version();
if (featRawParams?.Any() == true)
{
foreach (var featRawParam in featRawParams)
{
var paramName = featRawParam.Key;
//TODO: think about conversion
var paramVal = featRawParam.Value?.ToString();
if (paramName == VERSION_PARAMETERS_NAME)
{
paramsVersion = new Version(paramVal);
}
else if (paramName == VERSION_DIMENSIONS_NAME)
{
paramsVersion = new Version(paramVal);
}
else
{
parameters.Add(paramName, paramVal);
}
}
}
ConvertParameters(paramsType, paramsVersion, conv =>
{
parameters = conv.ConvertParameters(model, feat, parameters);
featBodies = conv.ConvertEditBodies(model, feat, featBodies);
featSels = conv.ConvertSelections(model, feat, featSels);
featDims = conv.ConvertDisplayDimensions(model, feat, featDims);
});
var resParams = Activator.CreateInstance(paramsType);
TraverseParametersDefinition(resParams.GetType(),
(prp) =>
{
AssignObjectsToProperty(resParams, featSels, prp, parameters);
},
(dimType, prp) =>
{
var dimIndices = GetObjectIndices(prp, parameters);
if (dimIndices.Length != 1)
{
throw new InvalidOperationException(
"It could only be one index associated with dimension");
}
var dimInd = dimIndices.First();
if (featDims.Length > dimInd)
{
var dispDim = featDims[dimInd];
//TODO: work with current configuration when assembly is supported
var val = dispDim.GetValue();
if (!double.IsNaN(val))
{
prp.SetValue(resParams, val, null);
}
dispDimParamsMap.Add(dimInd, prp.Name);
}
else
{
throw new IndexOutOfRangeException(
$"Dimension at index {dimInd} id not present in the macro feature");
}
},
(prp) =>
{
AssignObjectsToProperty(resParams, featBodies, prp, parameters);
},
prp =>
{
var paramVal = GetParameterValue(parameters, prp.Name);
object val = null;
if (paramVal != null)
{
if (prp.PropertyType.IsEnum)
{
val = Enum.Parse(prp.PropertyType, paramVal);
}
else
{
val = Convert.ChangeType(paramVal, prp.PropertyType);
}
}
prp.SetValue(resParams, val, null);
});
dispDims = featDims;
editBodies = featBodies;
sels = featSels;
state = GetState(feat, featDims);
dispDimParams = dispDimParamsMap.Values.ToArray();
return(resParams);
}
CustomFeatureRebuildResult IXCustomFeatureDefinition.OnRebuild(IXApplication app, IXDocument model, IXCustomFeature feature) => OnRebuild((ISwApplication)app, (ISwDocument)model, (ISwMacroFeature)feature);
public override void OnEditingCompleted(IXApplication app, IXDocument doc, IXCustomFeature <CabinetSizeData> feat,
CabinetSizeData data, CabinetConfiguratorPage page, PageCloseReasons_e reason)
{
page.Order.Db.Dispose();
}
protected abstract CustomFeatureOutdateState_e GetState(IXCustomFeature featData, IXDimension[] dispDims);
public virtual CustomFeatureRebuildResult OnRebuild(IXApplication app, IXDocument model, IXCustomFeature feature)
{
return(null);
}
public virtual bool OnEditDefinition(IXApplication app, IXDocument model, IXCustomFeature feature)
{
return(true);
}
public override void OnPageParametersChanged(IXApplication app, IXDocument doc, IXCustomFeature <CabinetSizeData> feat,
CabinetConfiguratorPage page)
{
UpdateStatuses(page);
}
public virtual IXBody[] ConvertEditBodies(IXDocument model, IXCustomFeature feat, IXBody[] editBodies)
{
return(editBodies);
}
public virtual CustomFeatureState_e OnUpdateState(IXApplication app, IXDocument model, IXCustomFeature feature)
{
return(CustomFeatureState_e.Default);
}
protected abstract void SetParametersToFeature(IXCustomFeature feat,
IXSelObject[] selection, IXBody[] editBodies, IXDimension[] dims, double[] dimValues, CustomFeatureParameter[] param);
bool IXCustomFeatureDefinition.OnEditDefinition(IXApplication app, IXDocument model, IXCustomFeature feature) => OnEditDefinition((ISwApplication)app, (ISwDocument)model, (SwMacroFeature)feature);
public virtual Dictionary <string, string> ConvertParameters(IXDocument model, IXCustomFeature feat, Dictionary <string, string> parameters)
{
return(parameters);
}
CustomFeatureState_e IXCustomFeatureDefinition.OnUpdateState(IXApplication app, IXDocument model, IXCustomFeature feature) => OnUpdateState((ISwApplication)app, (ISwDocument)model, (SwMacroFeature)feature);
public virtual IXSelObject[] ConvertSelections(IXDocument model, IXCustomFeature feat, IXSelObject[] selection)
{
return(selection);
}
