/// <summary>
/// Sets the currently selected element.
/// </summary>
/// <param name="element">The current element.</param>
public void SetElement(Elements.Element element)
{
if (_enchant != null)
{
Extensions.ToggleObject(_enchant, false);
}
_element = element;
switch (element)
{
case Elements.Element.Fire:
_enchant = _fireEnchant;
break;
case Elements.Element.Ice:
_enchant = _iceEnchant;
break;
case Elements.Element.Bolt:
_enchant = _boltEnchant;
break;
default:
_enchant = _fireEnchant;
break;
}
Extensions.ToggleObject(_enchant, false);
}
/// <summary>
/// Gets the value of a family parameter of the current family type, this applies to all family parameters (instance and type).
/// </summary>
/// <param name="parameterName">A family parameter of the current type.</param>
/// <param name="familyTypeName">The name of the family type.</param>
/// <returns>The parameter value.</returns>
public object GetParameterValueByName(string familyTypeName, string parameterName)
{
Autodesk.Revit.DB.FamilyParameter familyParameter = FamilyManager.get_Parameter(parameterName);
if (familyParameter == null)
{
throw new InvalidOperationException(Properties.Resources.ParameterNotFound);
}
TransactionManager.Instance.EnsureInTransaction(this.InternalFamilyDocument);
SetFamilyDocumentCurrentType(familyTypeName);
TransactionManager.Instance.TransactionTaskDone();
switch (familyParameter.StorageType)
{
case Autodesk.Revit.DB.StorageType.Integer:
return(FamilyManager.CurrentType.AsInteger(familyParameter) * UnitConverter.HostToDynamoFactor(familyParameter.Definition.GetSpecTypeId()));
case Autodesk.Revit.DB.StorageType.Double:
return(FamilyManager.CurrentType.AsDouble(familyParameter) * UnitConverter.HostToDynamoFactor(familyParameter.Definition.GetSpecTypeId()));
case Autodesk.Revit.DB.StorageType.String:
return(FamilyManager.CurrentType.AsString(familyParameter));
case Autodesk.Revit.DB.StorageType.ElementId:
Elements.Element element = ElementSelector.ByElementId(FamilyManager.CurrentType.AsElementId(familyParameter).IntegerValue);
return(element);
default:
return(null);
}
}
public DB.ElementId[] ToRevit(Elements.Element hyparElement, LoadContext context)
{
if (hyparElement is ElementInstance instance && instance.BaseDefinition is ContentElement content)
{
if (content.TryGetLoadedRevitFamily(context, out var familySymbol))
{
var insertionPoint = instance.Transform.Origin.ToXYZ(true);
var closestLevel = GetLevelClosestToZ(insertionPoint.Z, context.Document, out double offsetFromLevel);
var placedContent = context.Document.Create.NewFamilyInstance(insertionPoint, familySymbol, closestLevel, DB.Structure.StructuralType.NonStructural);
placedContent.LookupParameter("Elevation from Level")?.Set(offsetFromLevel);
try
{
SetRotationOfInstance(context.Document, instance, content, insertionPoint, placedContent);
}
catch (Exception e)
{
context.Logger.Error("Unable to set rotation of instance. Some kinds of elements do not support 3d rotation.");
context.Logger.Error(e.Message);
context.Logger.Error(e.StackTrace);
}
placedContent.SetInstanceParametersFromContent(content, context);
return(new DB.ElementId[] { placedContent.Id });
}
else
{
context.Logger.Error($"Unable to find family {content.Name}, so its instances were not placed.");
return(new DB.ElementId[] { });
}
}
public void ShouldHaveBlockTypeAndBlockId(Elements.Element element, string expectedType)
{
// arrange/act
var payload = SlackClient.SerializeObject(element);
// assert
payload.Should().Contain($"\"type\":\"{expectedType}\"");
}
public override bool CanTranslate(Load targetLoad, Elements.Element targetElement)
{
if (targetLoad is Loads.UniformLoad)
{
return(true);
}
return(false);
}
/// <summary>
/// Get Element's Parameter by Name
/// </summary>
/// <param name="element">Element</param>
/// <param name="name">Parameter Name</param>
/// <returns>Parameter</returns>
public static Elements.Parameter ParameterByName(Elements.Element element, string name)
{
var param = element.Parameters.Cast <Parameter>()
.OrderBy(x => x.InternalParameter.Id.IntegerValue)
.FirstOrDefault(x => x.InternalParameter.Definition.Name == name);
if (param == null)
{
return(null);
}
else
{
return(param);
}
}
private void addReferenceToAController(Models.Element modelElement, Elements.Element element)
{
if (controllerFields.Any(x => x.Name.Equals(modelElement.Name, StringComparison.CurrentCultureIgnoreCase)))
{
FieldInfo field = controllerFields.FirstOrDefault(x => x.Name.Equals(modelElement.Name, StringComparison.CurrentCultureIgnoreCase));
if (field.FieldType.Name.Equals(modelElement.Type))
{
field.SetValue(controller, element);
}
else
{
logger.Warning($"Field { field.Name } should be a type of { modelElement.Type }.");
}
}
}
/// <summary>
/// Sets the currently selected element.
/// </summary>
/// <param name="element">The current element.</param>
public void SetElement(Elements.Element element)
{
if (_enchant != null)
Extensions.ToggleObject(_enchant, false);
_element = element;
switch (element)
{
case Elements.Element.Fire:
_enchant = _fireEnchant;
break;
case Elements.Element.Ice:
_enchant = _iceEnchant;
break;
case Elements.Element.Bolt:
_enchant = _boltEnchant;
break;
default:
_enchant = _fireEnchant;
break;
}
Extensions.ToggleObject(_enchant, false);
}
public ADSK.ElementId[] ToRevit(Elements.Element hyparElement, LoadContext context)
{
var stdWall = hyparElement as Elements.StandardWall;
if (stdWall == null)
{
return(Array.Empty <ADSK.ElementId>());
}
var cl = stdWall.CenterLine.ToRevitCurve(true);
var offsetFromLevel = 0.0;
var level = context.Level ?? FromHyparExtensions.GetLevelClosestToZ(Units.MetersToFeet(stdWall.Transform.Origin.Z), context.Document, out offsetFromLevel);
var rvtWall = ADSK.Wall.Create(context.Document, cl, level.Id, false);
rvtWall.LookupParameter("Unconnected Height").Set(Units.MetersToFeet(stdWall.Height));
rvtWall.LookupParameter("Base Offset").Set(Units.MetersToFeet(offsetFromLevel));
// Letting the walls join as they are loaded causes many errors and walls that are missing.
// For now we disallow joining.
ADSK.WallUtils.DisallowWallJoinAtEnd(rvtWall, 0);
ADSK.WallUtils.DisallowWallJoinAtEnd(rvtWall, 1);
return(new ADSK.ElementId[] { rvtWall.Id });
}
public override TclCommand[] Translate(Load ld, Elements.Element targetElement, string targetElementTag)
{
var uld = (ld as Loads.UniformLoad);
var elm = targetElement as Elements.BarElement;
var localLoad =
uld.CoordinationSystem == CoordinationSystem.Local ?
uld.Direction :
elm.GetTransformationManager().TransformGlobalToLocal(uld.Direction);
localLoad = localLoad.GetUnit();
var buf = new List <TclCommand>();
buf.Add(new TclCommand("eleLoad", "-ele", targetElementTag,
"-type", "-beamUniform",
localLoad.Z * uld.Magnitude,
localLoad.Y * uld.Magnitude,
localLoad.X * uld.Magnitude));
return(buf.ToArray());
}
public abstract bool CanTranslate(Load targetLoad, Elements.Element targetElement);
public abstract TclCommand[] Translate(Load targetLoad, Elements.Element targetElement, string targetElementTag);
public ADSK.ElementId[] ToRevit(Elements.Element hyparElement, LoadContext context)
{
throw new NotImplementedException();
}
public void AddElement(Elements.Element elem)
{
elem.OnPassIntoDirector(screen);
elements.Add(elem);
}
