public static ParameterSettings AddParameterLinks(this ParameterSettings parameterSettings, Type type, IEnumerable <IParameterLink> parameterLinks, bool merge = true)
{
if (parameterSettings == null)
{
return(null);
}
if (type == null || parameterLinks == null || parameterLinks.Count() == 0)
{
return(parameterSettings);
}
ParameterSettings cloneSettings = parameterSettings.ShallowClone();
cloneSettings.ParameterMaps = new List <ParameterMap>(parameterSettings.ParameterMaps);
ParameterMap parameterMap = cloneSettings.ParameterMap(type);
if (parameterMap == null)
{
cloneSettings.ParameterMaps.Add(new ParameterMap {
Type = type, ParameterLinks = new List <IParameterLink>(parameterLinks)
});
}
else
{
cloneSettings.ParameterMaps.Remove(parameterMap);
cloneSettings.ParameterMaps.Add(parameterMap.AddParameterLinks(parameterLinks, merge));
}
return(cloneSettings);
}
public static ParameterSettings RemoveParameterLinks(this ParameterSettings parameterSettings, Type type, IEnumerable <string> propertyNames)
{
if (parameterSettings == null)
{
return(null);
}
if (type == null || propertyNames == null || propertyNames.Count() == 0)
{
return(parameterSettings);
}
ParameterMap parameterMap = parameterSettings.ParameterMaps.Find(x => x.Type == type);
if (parameterMap == null)
{
return(parameterSettings);
}
ParameterSettings cloneSettings = parameterSettings.ShallowClone();
cloneSettings.ParameterMaps = new List <ParameterMap>(parameterSettings.ParameterMaps);
cloneSettings.ParameterMaps.Remove(parameterMap);
cloneSettings.ParameterMaps.Add(parameterMap.RemoveParameterLinks(propertyNames));
return(cloneSettings);
}
public static ParameterSettings DefaultParameterSettings()
{
ParameterSettings settings = new ParameterSettings().AddParameterMaps(BH.Engine.Library.Query.Library("ParameterMaps").Where(x => x is ParameterMap).Cast <ParameterMap>());
settings.Name = "BH Default Parameter Settings";
return(settings);
}
private static void AnalyzeNamedType(SymbolAnalysisContext context, [NotNull] ParameterSettings settings)
{
var type = (INamedTypeSymbol)context.Symbol;
if (IsDelegate(type))
{
AnalyzeDelegate(type, context, settings);
}
}
public void SaveParameterSettings(string outputFile, string profileParameter)
{
var regStorage = BuildStorage();
ParameterSettings parameterSettings = new ParameterSettings(regStorage);
parameterSettings.Parameters.Outputfile = outputFile;
parameterSettings.Parameters.Profile = profileParameter;
parameterSettings.SaveData("");
}
public static ParameterMap ParameterMap(this ParameterSettings parameterSettings, Type type)
{
if (parameterSettings == null || parameterSettings.ParameterMaps == null)
{
return(null);
}
return(parameterSettings.ParameterMaps.Find(x => x != null && x.Type == type));
}
public ParameterCountInfo(BaseAnalysisContext <TTarget> context, [NotNull] ParameterSettings settings,
bool isConstructor = false)
{
Guard.NotNull(settings, nameof(settings));
Context = context;
this.settings = settings;
this.isConstructor = isConstructor;
}
private ParameterSettings LoadParameterSettings()
{
var regStorage = BuildStorage();
var parametersettings = new ParameterSettings(regStorage);
parametersettings.LoadData(regStorage, "");
return(parametersettings);
}
private static void AnalyzeProperty(SymbolAnalysisContext context, [NotNull] ParameterSettings settings)
{
var property = (IPropertySymbol)context.Symbol;
if (property.IsIndexer && MemberRequiresAnalysis(property, context.CancellationToken))
{
var info = new ParameterCountInfo <ImmutableArray <IParameterSymbol> >(context.Wrap(property.Parameters), settings);
AnalyzeParameters(info, property, "Indexer");
}
}
private static void AnalyzeLocalFunction(OperationAnalysisContext context, [NotNull] ParameterSettings settings)
{
var operation = (ILocalFunctionOperation)context.Operation;
string memberName = GetMemberName(operation.Symbol);
var info = new ParameterCountInfo <ImmutableArray <IParameterSymbol> >(context.Wrap(operation.Symbol.Parameters),
settings);
AnalyzeParameters(info, operation.Symbol, memberName);
AnalyzeReturnType(context.Wrap(operation.Symbol.ReturnType), operation.Symbol, memberName);
}
public static ParameterSettings ParameterSettings(IEnumerable <ParameterMap> parameterMaps = null, string tagsParameter = "", string materialGradeParameter = "")
{
ParameterSettings parameterSettings = new ParameterSettings();
if (parameterMaps != null)
{
parameterSettings = parameterSettings.AddParameterMaps(parameterMaps);
}
parameterSettings.TagsParameter = tagsParameter;
parameterSettings.MaterialGradeParameter = materialGradeParameter;
return(parameterSettings);
}
public static IEnumerable <IParameterLink> ParameterLinks(this ParameterSettings parameterSettings, Type type, string propertyName)
{
if (parameterSettings == null || parameterSettings.ParameterMaps == null || type == null || string.IsNullOrWhiteSpace(propertyName))
{
return(null);
}
ParameterMap parameterMap = parameterSettings.ParameterMap(type);
if (parameterMap == null)
{
return(null);
}
return(parameterMap.ParameterLinks(propertyName));
}
private static void AnalyzeDelegate([NotNull] INamedTypeSymbol type, SymbolAnalysisContext context,
[NotNull] ParameterSettings settings)
{
IMethodSymbol method = type.DelegateInvokeMethod;
if (method != null)
{
string typeName = $"Delegate '{type.Name}'";
var info = new ParameterCountInfo <ImmutableArray <IParameterSymbol> >(context.Wrap(method.Parameters), settings);
AnalyzeParameters(info, type, typeName);
AnalyzeReturnType(context.Wrap(method.ReturnType), type, typeName);
}
}
public static ParameterSettings AddParameterMaps(this ParameterSettings parameterSettings, IEnumerable <ParameterMap> parameterMaps, bool merge = true)
{
if (parameterSettings == null)
{
return(null);
}
if (parameterMaps == null || parameterMaps.Count() == 0)
{
return(parameterSettings);
}
ParameterSettings cloneSettings = parameterSettings.ShallowClone();
if (cloneSettings.ParameterMaps == null)
{
cloneSettings.ParameterMaps = new List <ParameterMap>();
}
else
{
cloneSettings.ParameterMaps = new List <ParameterMap>(cloneSettings.ParameterMaps);
}
foreach (ParameterMap parameterMap in parameterMaps)
{
ParameterMap cloneMap = cloneSettings.ParameterMaps.Find(x => parameterMap.Type == x.Type);
if (cloneMap == null)
{
cloneSettings.ParameterMaps.Add(parameterMap);
}
else
{
if (merge)
{
cloneSettings.ParameterMaps.Add(cloneMap.AddParameterLinks(parameterMap.ParameterLinks, true));
}
else
{
cloneSettings.ParameterMaps.Add(parameterMap);
}
cloneSettings.ParameterMaps.Remove(cloneMap);
}
}
return(cloneSettings);
}
private static void RegisterCompilationStart([NotNull] CompilationStartAnalysisContext startContext)
{
Guard.NotNull(startContext, nameof(startContext));
ParameterSettings settings = GetParameterSettings(startContext.Options, startContext.CancellationToken);
startContext.RegisterSymbolAction(actionContext => AnalyzePropertyAction(actionContext, settings),
SymbolKind.Property);
startContext.RegisterSymbolAction(actionContext => AnalyzeMethodAction(actionContext, settings), SymbolKind.Method);
startContext.RegisterSymbolAction(actionContext => AnalyzeNamedTypeAction(actionContext, settings),
SymbolKind.NamedType);
startContext.RegisterOperationAction(actionContext => AnalyzeLocalFunctionAction(actionContext, settings),
OperationKind.LocalFunction);
}
public static ParameterSettings RemoveParameterMaps(this ParameterSettings parameterSettings, IEnumerable <Type> types)
{
if (parameterSettings == null)
{
return(null);
}
if (parameterSettings.ParameterMaps == null)
{
return(parameterSettings);
}
ParameterSettings cloneSettings = parameterSettings.ShallowClone();
cloneSettings.ParameterMaps = parameterSettings.ParameterMaps.Where(x => types.All(y => x.Type != y)).ToList();
return(cloneSettings);
}
//This is for other classes to read parameter data.
public ParameterSettings GetParameters()
{
String ParaPath = Application.StartupPath + "\\Parameters.para";
FileStream FS = new FileStream(ParaPath, FileMode.Open, FileAccess.Read);
StreamReader ReadPara = new StreamReader(FS);
String Line = ReadPara.ReadLine();
FS.Close();
String[] Param = Line.Split(',');
ParameterSettings paradata = new ParameterSettings();
paradata.DataNoiseTheshold = Convert.ToDouble(Param[0]);
paradata.MinScoreThreshold = Convert.ToDouble(Param[1]);
paradata.MatchErrorEM = Convert.ToDouble(Param[2]);
paradata.MolecularWeightLowerBound = Convert.ToInt32(Param[3]);
paradata.MolecularWeightUpperBound = Convert.ToInt32(Param[4]);
paradata.GroupingErrorEG = Convert.ToDouble(Param[5]);
paradata.AdductToleranceEA = Convert.ToDouble(Param[6]);
paradata.MinScanNumber = Convert.ToInt32(Param[7]);
return paradata;
}
public static HashSet <string> ParameterNames(this ParameterSettings parameterSettings, Type type, string name, bool typeParameters = false)
{
if (parameterSettings == null || type == null || string.IsNullOrWhiteSpace(name))
{
return(null);
}
ParameterMap parameterMap = parameterSettings.ParameterMap(type);
if (parameterMap == null || parameterMap.ParameterLinks == null)
{
return(null);
}
Type linkType = typeParameters ? typeof(ElementTypeParameterLink) : typeof(ElementParameterLink);
IEnumerable <IParameterLink> parameterLinks = parameterMap.ParameterLinks.Where(x => x.PropertyName == name && x.GetType() == linkType);
return(new HashSet <string>(parameterLinks.SelectMany(x => x.ParameterNames)));
}
private static void AnalyzeMethod(SymbolAnalysisContext context, [NotNull] ParameterSettings settings)
{
var method = (IMethodSymbol)context.Symbol;
if (!method.IsPropertyOrEventAccessor() && MemberRequiresAnalysis(method, context.CancellationToken))
{
string memberName = GetMemberName(method);
bool isConstructor = IsConstructor(method);
var info = new ParameterCountInfo <ImmutableArray <IParameterSymbol> >(context.Wrap(method.Parameters), settings,
isConstructor);
AnalyzeParameters(info, method, memberName);
if (MethodCanReturnValue(method))
{
AnalyzeReturnType(context.Wrap(method.ReturnType), method, memberName);
}
}
}
/***************************************************/
/**** Public methods ****/
/***************************************************/
public static void SetProperties(this IObject iObject, Element element, ParameterSettings settings = null)
{
if (iObject == null || settings == null || settings.ParameterMaps == null || settings.ParameterMaps.Count == 0 || element == null)
{
return;
}
Type type = iObject.GetType();
IEnumerable <PropertyInfo> propertyInfos = type.MapPropertyInfos();
if (propertyInfos == null || propertyInfos.Count() == 0)
{
return;
}
Element elementType = element.Document.GetElement(element.GetTypeId());
foreach (PropertyInfo pInfo in propertyInfos)
{
HashSet <string> parameterNames = settings.ParameterNames(type, pInfo.Name, false);
if (parameterNames != null && iObject.SetProperty(pInfo, element, parameterNames))
{
continue;
}
if (elementType == null)
{
continue;
}
parameterNames = settings.ParameterNames(type, pInfo.Name, true);
if (parameterNames != null)
{
iObject.SetProperty(pInfo, elementType, parameterNames);
}
}
}
public void SaveParameterSettings(string outputFile, string profileParameter, string originalFilePath)
{
var parameters = new Parameters();
parameters.Outputfile = outputFile;
parameters.Profile = profileParameter;
parameters.OriginalFilePath = originalFilePath;
if (!ParametersAreSet(parameters))
{
return;
}
var parameterSettings = new ParameterSettings {
Parameters = parameters
};
var regStorage = BuildStorage();
parameterSettings.SaveData(regStorage);
_logger.Debug($"Saved Parameters into registry:\n" +
$"OutputFile: {outputFile}\n" +
$"Profile: {profileParameter}\n" +
$"OriginalFilePath: {originalFilePath}");
}
private void ParamSection()
{
if (PaddedBoxGS == null)
{
PaddedBoxGS = new GUIStyle((GUIStyle)"HelpBox")
{
normal = ((GUIStyle)"GroupBox").normal, padding = new RectOffset(4, 4, 4, 4)
}
}
;
if (PaddedGS == null)
{
PaddedGS = new GUIStyle(PaddedBoxGS)
{
normal = ((GUIStyle)"MiniLabel").normal
}
}
;
t.useGlobalParamSettings = EditorGUILayout.ToggleLeft("Use Global Settings", t.useGlobalParamSettings);
showAdvancedParams[uid] = IndentedFoldout(new GUIContent("Adv. Parameter Settings"), showAdvancedParams[uid], 1);
if (showAdvancedParams[uid])
{
var indenthold = EditorGUI.indentLevel;
EditorGUI.indentLevel = 0;
EditorGUILayout.BeginHorizontal();
EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1));
EditorGUILayout.LabelField(label_Interp, (GUIStyle)"MiniLabel", GUILayout.MaxWidth(COL2));
EditorGUILayout.LabelField(label_Extrap, (GUIStyle)"MiniLabel", GUILayout.MaxWidth(COL3));
EditorGUILayout.LabelField(label_Default, (GUIStyle)"MiniLabel", GUILayout.MaxWidth(COL4));
EditorGUILayout.EndHorizontal();
var defs = t.sharedParamDefaults;
if (t.useGlobalParamSettings)
{
EditorGUILayout.BeginHorizontal();
InspectorWidgets.MiniToggle(t, EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1)), new GUIContent("Ints"), ref defs.includeInts);
DrawInterp(AnimatorControllerParameterType.Int, ref defs.interpolateInts);
DrawExtrap(AnimatorControllerParameterType.Int, ref defs.extrapolateInts);
DrawDefaults(AnimatorControllerParameterType.Int, ref defs.defaultInt);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
InspectorWidgets.MiniToggle(t, EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1)), new GUIContent("Floats"), ref defs.includeFloats);
DrawInterp(AnimatorControllerParameterType.Float, ref defs.interpolateFloats);
DrawExtrap(AnimatorControllerParameterType.Float, ref defs.extrapolateFloats);
DrawDefaults(AnimatorControllerParameterType.Float, ref defs.defaultFloat);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
InspectorWidgets.MiniToggle(t, EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1)), new GUIContent("Bools"), ref defs.includeBools);
EditorGUILayout.GetControlRect(GUILayout.MaxWidth(COL2));
DrawExtrap(AnimatorControllerParameterType.Bool, ref defs.extrapolateBools);
DrawDefaults(AnimatorControllerParameterType.Bool, ref defs.defaultBool);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
var tr = EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1));
InspectorWidgets.MiniToggle(t, tr, triggerLabel, ref defs.includeTriggers);
if (t.sharedParamDefaults.includeTriggers)
{
GUI.DrawTexture(new Rect(tr)
{
x = 2, width = 16
}, EditorGUIUtility.FindTexture("console.warnicon"));
}
EditorGUILayout.GetControlRect(GUILayout.MaxWidth(COL2));
DrawExtrap(AnimatorControllerParameterType.Trigger, ref defs.extrapolateTriggers);
DrawDefaults(AnimatorControllerParameterType.Trigger, ref defs.defaultTrigger);
EditorGUILayout.EndHorizontal();
}
else
{
var names = ParameterSettings.RebuildParamSettings(a, ref t.sharedParamSettings, ref t.paramCount, t.sharedParamDefaults);
serializedObject.Update();
var pms = t.sharedParamSettings;
for (int i = 0; i < t.paramCount; ++i)
{
var pm = pms[i];
EditorGUILayout.BeginHorizontal();
// Type Letter Box (left vertical)
EditorGUILayout.BeginVertical(PaddedBoxGS, GUILayout.MaxWidth(8));
TypeLabel(EditorGUILayout.GetControlRect(GUILayout.MaxWidth(12)), pm.paramType);
EditorGUILayout.EndVertical();
// Main Vertical (Right)
EditorGUILayout.BeginVertical((pm.include) ? PaddedBoxGS : PaddedGS);
EditorGUILayout.BeginHorizontal();
InspectorWidgets.MiniToggle(t, EditorGUILayout.GetControlRect(GUILayout.MinWidth(COL1)), new GUIContent(names[i]), ref pm.include);
EditorGUI.BeginDisabledGroup(!pm.include);
DrawInterp(pm.paramType, ref pm.interpolate);
DrawExtrap(pm.paramType, ref pm.extrapolate);
DrawDefaults(pm.paramType, ref pm.defaultValue);
EditorGUI.EndDisabledGroup();
EditorGUILayout.EndHorizontal();
// Compression Row
if (pm.include)
{
if (pm.paramType == AnimatorControllerParameterType.Float || pm.paramType == AnimatorControllerParameterType.Int)
{
var sharedPSs = serializedObject.FindProperty("sharedParamSettings");
var ps = sharedPSs.GetArrayElementAtIndex(i);
var fcrusher = (pm.paramType == AnimatorControllerParameterType.Float) ? ps.FindPropertyRelative("fcrusher") : ps.FindPropertyRelative("icrusher");
var r = EditorGUILayout.GetControlRect(false, EditorGUI.GetPropertyHeight(fcrusher));
Rect rectCrusher = new Rect(r)
{
height = 16
};
EditorGUI.PropertyField(rectCrusher, fcrusher);
}
}
// End Right Vertical
EditorGUILayout.EndVertical();
// End Parameter
EditorGUILayout.EndHorizontal();
}
}
EditorGUI.indentLevel = indenthold;
}
}
public static RevitSettings RevitSettings(ConnectionSettings connectionSettings = null, FamilyLoadSettings familyLoadSettings = null, ParameterSettings parameterSettings = null, double distanceTolerance = BH.oM.Geometry.Tolerance.Distance, double angleTolerance = BH.oM.Geometry.Tolerance.Angle)
{
RevitSettings settings = new RevitSettings();
if (connectionSettings != null)
{
settings.ConnectionSettings = connectionSettings;
}
if (familyLoadSettings != null)
{
settings.FamilyLoadSettings = familyLoadSettings;
}
if (parameterSettings != null)
{
settings.ParameterSettings = parameterSettings;
}
if (!double.IsNaN(distanceTolerance))
{
settings.DistanceTolerance = distanceTolerance;
}
if (!double.IsNaN(distanceTolerance))
{
settings.AngleTolerance = angleTolerance;
}
return(settings);
}
/***************************************************/
public static Parameter LookupParameter(this Element element, ParameterSettings parameterSettings, Type type, string name, bool mustHaveValue = true)
{
if (element == null || parameterSettings == null || type == null)
{
return(null);
}
// Lookup element parameter.
List <string> names = new List <string> {
name
};
HashSet <string> paramNames = parameterSettings.ParameterNames(type, name, false);
if (paramNames != null)
{
names.AddRange(paramNames);
}
foreach (string val in names)
{
Parameter parameter = element.LookupParameter(val);
if (parameter == null)
{
continue;
}
if (parameter.HasValue || !mustHaveValue)
{
return(parameter);
}
}
// Lookup element type parameter (if specified in parameterSettings).
paramNames = parameterSettings.ParameterNames(type, name, true);
if (paramNames == null || paramNames.Count == 0)
{
return(null);
}
Element elementType = element.Document.GetElement(element.GetTypeId());
if (elementType == null)
{
return(null);
}
foreach (string val in paramNames)
{
Parameter parameter = elementType.LookupParameter(val);
if (parameter == null)
{
continue;
}
if (parameter.HasValue || !mustHaveValue)
{
return(parameter);
}
}
return(null);
}
/***************************************************/
/**** Public methods ****/
/***************************************************/
public static void CopyParameters(this IBHoMObject bHoMObject, Element element, ParameterSettings settings = null)
{
if (bHoMObject == null || element == null)
{
return;
}
List <RevitParameter> parameters = new List <RevitParameter>();
oM.Adapters.Revit.Parameters.ParameterMap parameterMap = settings?.ParameterMap(bHoMObject.GetType());
IEnumerable <IParameterLink> parameterLinks = null;
if (parameterMap != null)
{
Element elementType = element.Document.GetElement(element.GetTypeId());
IEnumerable <IParameterLink> typeParameterLinks = parameterMap.ParameterLinks.Where(x => x is ElementTypeParameterLink);
if (elementType != null && typeParameterLinks.Count() != 0)
{
foreach (Parameter parameter in elementType.ParametersMap)
{
RevitParameter bHoMParameter = parameter.ParameterFromRevit(typeParameterLinks, true);
if (bHoMParameter != null)
{
parameters.Add(bHoMParameter);
}
}
}
parameterLinks = parameterMap.ParameterLinks.Where(x => !(x is ElementTypeParameterLink));
}
IEnumerable elementParams = element.ParametersMap;
if (((Autodesk.Revit.DB.ParameterMap)elementParams).IsEmpty)
{
elementParams = element.Parameters;
}
foreach (Parameter parameter in elementParams)
{
parameters.Add(parameter.ParameterFromRevit(parameterLinks, false));
}
bHoMObject.Fragments.Add(new RevitPulledParameters(parameters));
}