/// <summary> /// Calculates the distance to the next level if the UpToLevel parameter is set. /// If the parameter is not set, or the distance is negative, 0 is returned. /// This is not set in IFCLevelInfo as we want this calculation to be done in .NET code. /// </summary> /// <param name="doc">The document.</param> /// <param name="levelId">The element id of the level.</param> /// <param name="levelInfo">The associated level information object.</param> public static double CalculateDistanceToNextLevel(Document doc, ElementId levelId, IFCLevelInfo levelInfo) { double height = 0.0; Level level = doc.GetElement(levelId) as Level; ElementId nextLevelId = ElementId.InvalidElementId; if (level != null) { Parameter nextLevelParameter = level.get_Parameter(BuiltInParameter.LEVEL_UP_TO_LEVEL); if (nextLevelParameter != null) { Element nextLevelAsElement = doc.GetElement(nextLevelParameter.AsElementId()); if (nextLevelAsElement != null) { Level possibleNextLevel = nextLevelAsElement as Level; if (possibleNextLevel != null && IsBuildingStory(possibleNextLevel)) { double nextLevelElevation = possibleNextLevel.Elevation; double netElevation = nextLevelElevation - level.Elevation; if (netElevation > 0.0) { height = netElevation; nextLevelId = nextLevelParameter.AsElementId(); } } } } } if ((height <= 0.0) && (levelInfo != null)) height = levelInfo.DistanceToNextLevel; ExporterCacheManager.LevelInfoCache.Register(levelId, nextLevelId, height); return height; }
string GetParamValueAsStr(Parameter parameter) { switch (parameter.StorageType) { case StorageType.String: return(parameter.AsString()); case StorageType.Integer: return(parameter.AsInteger().ToString()); case StorageType.Double: return(parameter.AsValueString()); case StorageType.ElementId: ElementId eid = parameter.AsElementId(); if (eid.IntegerValue < 0) { return("(none)"); } else { return(parameter .Element .Document .GetElement(parameter.AsElementId()).Name); } case StorageType.None: return("N/A"); default: return("N/A"); } }
public static ElementId GetBaseLevelIdForElement(Element elem) { if (elem.ViewSpecific) { ElementId viewId = elem.OwnerViewId; ElementId viewSpecificlevelId; if (ExporterCacheManager.DBViewsToExport.TryGetValue(viewId, out viewSpecificlevelId)) { return(viewSpecificlevelId); } } Parameter levelParameter = null; if (elem is FamilyInstance) { // If this is a nested family, check the top-level instance for the level parameter information. Element elemToCheck = (elem as FamilyInstance).SuperComponent; if (elemToCheck == null) { elemToCheck = elem; } // There are two Family-related parameters: INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM and INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM. // We prioritize INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM over INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM. levelParameter = elemToCheck.get_Parameter(BuiltInParameter.INSTANCE_SCHEDULE_ONLY_LEVEL_PARAM); if (levelParameter != null && levelParameter.StorageType == StorageType.ElementId) { ElementId levelId = levelParameter.AsElementId(); if (levelId != ElementId.InvalidElementId) { return(levelId); } } levelParameter = elemToCheck.get_Parameter(BuiltInParameter.INSTANCE_REFERENCE_LEVEL_PARAM); } else if (elem is Truss) { levelParameter = elem.get_Parameter(BuiltInParameter.TRUSS_ELEMENT_REFERENCE_LEVEL_PARAM); } else if (elem is Stairs || StairsExporter.IsLegacyStairs(elem)) { levelParameter = elem.get_Parameter(BuiltInParameter.STAIRS_BASE_LEVEL_PARAM); } else if (elem is ExtrusionRoof) { levelParameter = elem.get_Parameter(BuiltInParameter.ROOF_CONSTRAINT_LEVEL_PARAM); } if (levelParameter != null && levelParameter.StorageType == StorageType.ElementId) { return(levelParameter.AsElementId()); } else { return(elem.LevelId); } }
private static void updateView(View v, StyleEnum style) { if (testDocNeedsInitializing(v.Document)) { createAllStyles(v.Document); } //does the current view have an analysis style? Parameter avf = v.get_Parameter(BuiltInParameter.VIEW_ANALYSIS_DISPLAY_STYLE); Document doc = v.Document; if (avf != null) { ElementId eid = avf.AsElementId(); string name = ""; switch (style) { case StyleEnum.Faces: name = "SolidView"; break; case StyleEnum.Vectors: name = "VectorView"; break; default: throw new ApplicationException("Unexpected Display Style: " + style); } ElementId pc = AnalysisDisplayStyle.FindByName(doc, name); if (pc.IntegerValue > 0) { if (avf.AsElementId() != pc) { Transaction t = null; if (v.Document.IsModifiable == false) { t = new Transaction(v.Document, "Set AVF view style"); t.Start(); } bool success = avf.Set(pc); if (t != null) { t.Commit(); } } } } }
//public static ParameterForm GetParameterForm(this Parameter param, Document doc) //{ // ParameterForm pf = ParameterForm.None; // Debug.WriteLine("This parameter's type is: " + param.Definition.ParameterType.ToString()); // if (!param.Definition.ParameterType.ToString().Equals("Invalid")) // { // try // { // DefinitionBindingMap dbm = doc.ParameterBindings; // Debug.WriteLine("The DefinitionBindingMap has " + dbm.Size.ToString() + "entries"); // Definition d = param.Definition; // Binding b = dbm.get_Item(d); // Debug.Assert(b is InstanceBinding, (d.Name + " is an instance")); // Debug.Assert(b is TypeBinding, (d.Name + " is a type")); // } // catch (Autodesk.Revit.Exceptions.InvalidObjectException invOe) // { // // coode // Debug.WriteLine("The object was invalid?" + "\n" + invOe.Message); // } // catch (Autodesk.Revit.Exceptions.InvalidOperationException auto_ioe) // { // // code // Debug.WriteLine("The operation was invalid?" + "\n" + auto_ioe.Message); // } // } // return pf; //} public static string GetParameterValue(this Parameter param) { try { switch (param.StorageType) { default: // A NULL VALUE MEANS THE PARAMETER IS UNEXPOSED return("PARAMETER HAS NOT BEEN EXPOSED"); case StorageType.Double: return(GetParameterDouble(param)); case StorageType.Integer: if (ParameterType.YesNo != param.Definition.ParameterType) { return("INTEGER: " + param.AsInteger().ToString()); } if (param.AsInteger() == 0) { return("False"); } return("True"); case StorageType.String: return(param.AsString()); case StorageType.ElementId: // this one is tricky // a positive ElementID can point to a specific element // however a negative one can mean a number of different things if (param.AsElementId().IntegerValue <= 0) { return("ELEMENTID: " + param.AsElementId().IntegerValue.ToString()); } using (Document paramdoc = param.Element.Document) { return(paramdoc.GetElement(param.AsElementId()).Name); } } } catch (InvalidObjectException invalidoex) { ExceptionReport.DebugLog(invalidoex); } return(null); }
public static IEnumerable <ElementId> ElementIdsByParameter(this Document document, string parameterName, int elementId, IEnumerable <ElementId> ids = null) { if (document == null) { return(null); } HashSet <ElementId> result = new HashSet <ElementId>(); if (ids != null && ids.Count() == 0) { return(result); } FilteredElementCollector collector = ids == null ? new FilteredElementCollector(document) : new FilteredElementCollector(document, ids.ToList()); foreach (Element element in collector.WherePasses(new LogicalOrFilter(new ElementIsElementTypeFilter(), new ElementIsElementTypeFilter(true)))) { Parameter param = element.LookupParameter(parameterName); if (param != null && param.HasValue && param.StorageType == StorageType.ElementId) { if (param.AsElementId().IntegerValue == elementId) { result.Add(element.Id); } } } return(result); }
/// <summary> /// The GetParameterValue /// </summary> /// <param name="Paramètre">The Paramètre<see cref="Parameter"/></param> /// <returns>The <see cref="string"/></returns> public static string GetParameterValue(Parameter Paramètre) { switch (Paramètre.StorageType) { case StorageType.Double: //// Obtenir la valeur du paramètre sans unité. //return paramètre.AsDouble(); // Changer la valeur de retour. // Obtenir la valeur du paramètre avec unité. return(Paramètre.AsValueString()); case StorageType.ElementId: return(Paramètre.AsElementId().IntegerValue.ToString()); case StorageType.Integer: return(Paramètre.AsValueString()); case StorageType.None: return(Paramètre.AsValueString()); case StorageType.String: return(Paramètre.AsString()); default: return(""); } }
/// <summary> /// Gets element filter that match certain phases. /// </summary> /// <param name="document">The Revit document.</param> /// <returns>The element filter.</returns> private static ElementFilter GetPhaseStatusFilter(Document document, Element filterView) { List <ElementOnPhaseStatus> phaseStatuses = new List <ElementOnPhaseStatus>(); phaseStatuses.Add(ElementOnPhaseStatus.None); //include "none" because we might want to export phaseless elements. phaseStatuses.Add(ElementOnPhaseStatus.Existing); phaseStatuses.Add(ElementOnPhaseStatus.New); PhaseArray phaseArray = document.Phases; ElementId phaseId = ElementId.InvalidElementId; if (filterView != null) { Parameter currPhase = filterView.get_Parameter(BuiltInParameter.VIEW_PHASE); if (currPhase != null) { phaseId = currPhase.AsElementId(); } } if (phaseId == ElementId.InvalidElementId) { Phase lastPhase = phaseArray.get_Item(phaseArray.Size - 1); phaseId = lastPhase.Id; } return(new ElementPhaseStatusFilter(phaseId, phaseStatuses)); }
public object GetParameterValue(Parameter parameter) { object returnValue = null; if (parameter == null || !parameter.HasValue) { return(returnValue); } switch (parameter.StorageType) { case StorageType.Double: returnValue = parameter.AsDouble(); break; case StorageType.Integer: returnValue = parameter.AsInteger(); break; case StorageType.String: returnValue = parameter.AsString(); break; case StorageType.ElementId: returnValue = parameter.AsElementId(); break; } return(returnValue); }
public static string GetParameterValueString(this Parameter param) { string empty = string.Empty; string str; switch ((int)param.StorageType) { case 0: str = param.AsValueString().ToString(); break; case 1: str = param.AsInteger().ToString(); break; case 2: str = param.AsDouble().ToString(CultureInfo.InvariantCulture); break; case 3: str = param.AsString(); break; case 4: str = param.AsElementId().ToString(); break; default: str = param.AsValueString(); break; } return(str ?? string.Empty); }
private Room getOtherRoom(Room r1, BoundarySegment seg, XYZ point) { // we already know what one of the rooms is attached to a boundary segment. // this attempts to find the other. Curve crv = seg.GetCurve(); XYZ vector = crv.GetEndPoint(1).Subtract(crv.GetEndPoint(0)).Normalize(); XYZ otherVector = XYZ.BasisZ; if (vector.IsAlmostEqualTo(XYZ.BasisZ)) { otherVector = XYZ.BasisY; } XYZ perp = vector.CrossProduct(otherVector).Normalize(); XYZ testp1 = point.Add(perp.Multiply(0.25)); XYZ testp2 = point.Add(perp.Negate().Multiply(0.25)); Parameter phaseParm = r1.get_Parameter(BuiltInParameter.ROOM_PHASE); Phase p = _doc.GetElement(phaseParm.AsElementId()) as Phase; Room roomP1 = _doc.GetRoomAtPoint(testp1, p); Room roomP2 = _doc.GetRoomAtPoint(testp2, p); if ((roomP1 != null) && (roomP1.Id != r1.Id)) { return(roomP1); } if ((roomP2 != null) && (roomP2.Id != r1.Id)) { return(roomP2); } return(null); }
//Sets the value of the family parameter based on a parameter value private void SetDocumentParameter(FamilyParameter docParameter, Parameter famParameter) { switch (famParameter.StorageType) { case (StorageType.Double): var value = famParameter.AsDouble(); familyManager.Set(docParameter, famParameter.AsDouble()); break; case (StorageType.Integer): familyManager.Set(docParameter, famParameter.AsInteger()); break; case (StorageType.String): familyManager.Set(docParameter, famParameter.AsString()); break; case (StorageType.ElementId): familyManager.Set(docParameter, famParameter.AsElementId()); break; case (StorageType.None): break; } }
public void GetParameters() { Document doc = Column.Document; FamilySymbol type = Column.Symbol; Width = type.LookupParameter("b").AsDouble(); Height = type.LookupParameter("h").AsDouble(); LocationPoint lp = Column.Location as LocationPoint; XYZ p = lp.Point; Parameter blP = Column.LookupParameter("Base Level"); Parameter boP = Column.LookupParameter("Base Offset"); Level bl = doc.GetElement(blP.AsElementId()) as Level; double bo = boP.AsDouble(); Parameter tlP = Column.LookupParameter("Top Level"); Parameter toP = Column.LookupParameter("Top Offset"); Level tl = doc.GetElement(tlP.AsElementId()) as Level; double to = toP.AsDouble(); DrivingCurve = Line.CreateBound(new XYZ(p.X, p.Y, bl.Elevation + bo), new XYZ(p.X, p.Y, tl.Elevation + to)); Length = DrivingCurve.Length; }
public static bool ResetValue(this Parameter parameter) { if (!parameter.HasValue) { return(true); } #if REVIT_2020 if (parameter.IsShared && (parameter.Definition as ExternalDefinition).HideWhenNoValue) { return(parameter.ClearValue()); } #endif switch (parameter.StorageType) { case StorageType.Integer: return(parameter.AsInteger() == 0 || parameter.Set(0)); case StorageType.Double: return(parameter.AsDouble() == 0.0 || parameter.Set(0.0)); case StorageType.String: return(parameter.AsString() == string.Empty || parameter.Set(string.Empty)); case StorageType.ElementId: return(parameter.AsElementId() == ElementId.InvalidElementId || parameter.Set(ElementId.InvalidElementId)); } return(false); }
public static string GetParameterAsString(Element element, string v) { if (element == null) { return(string.Empty); } Parameter p = element.LookupParameter(v); if (p != null) { switch (p.StorageType) { case StorageType.Double: //if (p.DisplayUnitType != DisplayUnitType.DUT_UNDEFINED) //{ return(p.AsValueString()); //} //else //{ //} case StorageType.Integer: return(p.AsInteger().ToString()); case StorageType.ElementId: Element e = element.Document.GetElement(p.AsElementId()); return(e != null ? e.Name : "None"); case StorageType.String: return(p.AsString() != null?p.AsString() : "-"); } } return(string.Empty); }
public static string GetParameterValueString(Element e, BuiltInParameter bip) { Parameter p = e.get_Parameter(bip); string s = string.Empty; if (null != p) { switch (p.StorageType) { case StorageType.Integer: s = p.AsInteger().ToString(); break; case StorageType.ElementId: s = p.AsElementId().IntegerValue.ToString(); break; case StorageType.Double: s = p.AsDouble().ToString(); break; case StorageType.String: s = p.AsDouble().ToString(); break; default: s = ""; break; } } return(s); }
public static int GetConcreteClass(Element elem) { Document doc = elem.Document; Element elemType = doc.GetElement(elem.GetTypeId()); Parameter materialParam = elemType.get_Parameter(BuiltInParameter.STRUCTURAL_MATERIAL_PARAM); if (materialParam == null || !materialParam.HasValue) { throw new Exception("No Structural Material in element " + elem.Id.IntegerValue.ToString()); } Material mat = doc.GetElement(materialParam.AsElementId()) as Material; if (mat == null) { throw new Exception("Unable to get Material from element " + elem.Id.IntegerValue.ToString()); } Parameter materialCodeParam = mat.LookupParameter("Мтрл.КодМатериала"); if (materialCodeParam == null || !materialCodeParam.HasValue) { throw new Exception("Нет параметра Мтрл.КодМатериала в материале " + mat.Name); } int materialCode = materialCodeParam.AsInteger() / 100000; int concreteClass = materialCode % 100; return(concreteClass); }
public string GetParameterValue(Parameter parameter) { string s; switch (parameter.StorageType) { case StorageType.Double: s = RealString(parameter.AsDouble()); break; case StorageType.Integer: s = parameter.AsInteger().ToString(); break; case StorageType.String: s = parameter.AsString(); break; case StorageType.ElementId: s = parameter.AsElementId().IntegerValue.ToString(); break; case StorageType.None: s = ""; break; default: s = "0.0"; break; } return(s); }
private static string GetParameterValue(Parameter param) { if (param == null) { return(string.Empty); } string str; switch (param.StorageType) { case StorageType.Integer: str = param.AsInteger().ToString(); break; case StorageType.Double: str = param.AsDouble().ToString(CultureInfo.InvariantCulture); break; case StorageType.String: str = param.AsString(); break; case StorageType.ElementId: str = param.AsElementId().ToString(); break; default: str = param.AsString(); break; } return(str ?? string.Empty); }
public static string GetAsString(Parameter param) { switch (param.StorageType) { case StorageType.None: return(""); case StorageType.Integer: return(param.AsInteger().ToString()); case StorageType.Double: double doubleval = param.AsDouble(); if (param.Definition.UnitType == UnitType.UT_Length) { doubleval *= 304.8; } return(doubleval.ToString("F1")); case StorageType.String: return(param.AsString()); case StorageType.ElementId: int intval = param.AsElementId().IntegerValue; return(intval.ToString()); default: return(""); } }
/// <summary> /// Helper to return parameter value as string, with additional /// support for element id to display the element type referred to. /// </summary> public static string GetParameterValue2(Parameter param, Document doc) { string s; if (StorageType.ElementId == param.StorageType && null != doc) { ElementId id = param.AsElementId(); int i = id.IntegerValue; if (0 > i) { s = i.ToString() + BuiltInCategoryString(i); } else { Element e = doc.GetElement(id); s = ElementDescription(e, true); } } else { s = GetParameterValue(param); } return(s); }
private static Value _getParam(Parameter p) { switch (p.StorageType) { case StorageType.ElementId: return(Value.NewContainer(p.AsElementId())); case StorageType.String: return(Value.NewString(p.AsString())); case StorageType.Integer: case StorageType.Double: switch (p.Definition.ParameterType) { case ParameterType.Length: return(Value.NewContainer(Units.Length.FromFeet(p.AsDouble(), dynSettings.Controller.UnitsManager))); case ParameterType.Area: return(Value.NewContainer(Units.Area.FromSquareFeet(p.AsDouble(), dynSettings.Controller.UnitsManager))); case ParameterType.Volume: return(Value.NewContainer(Units.Volume.FromCubicFeet(p.AsDouble(), dynSettings.Controller.UnitsManager))); default: return(Value.NewNumber(p.AsDouble())); } default: throw new Exception(string.Format("Parameter {0} has no storage type.", p)); } }
private void UpdatePhaseAttributes(IFCExportConfiguration configuration) { if (configuration.VisibleElementsOfCurrentView) { UIDocument uiDoc = new UIDocument(IFCCommandOverrideApplication.TheDocument); Parameter currPhase = uiDoc.ActiveView.get_Parameter(BuiltInParameter.VIEW_PHASE); if (currPhase != null) { configuration.ActivePhaseId = currPhase.AsElementId(); } else { configuration.ActivePhaseId = ElementId.InvalidElementId; } } if (!IFCPhaseAttributes.Validate(configuration.ActivePhaseId)) { configuration.ActivePhaseId = ElementId.InvalidElementId; } foreach (IFCPhaseAttributes attribute in comboboxActivePhase.Items.Cast <IFCPhaseAttributes>()) { if (configuration.ActivePhaseId == attribute.PhaseId) { comboboxActivePhase.SelectedItem = attribute; break; } } comboboxActivePhase.IsEnabled = !configuration.VisibleElementsOfCurrentView; }
private void checkBox_Unchecked(object sender, EventArgs e) { CheckBox cb = sender as CheckBox; TreeViewItem tvi = cb.Parent as TreeViewItem; if (tvi.HasItems) { foreach (TreeViewItem tvitest in tvi.Items) { (tvitest.Header as CheckBox).IsChecked = false; } } else { Parameter p = cb.Tag as Parameter; foreach (ElementId ei in elementsId) { Parameter par = doc.GetElement(ei).get_Parameter(p.Definition); if (Math.Round(par.AsDouble()) == Math.Round(p.AsDouble()) && par.AsElementId() == p.AsElementId() && par.AsInteger() == p.AsInteger() && par.AsString() == p.AsString() && par.AsValueString() == p.AsValueString()) { filteredElementId.Remove(ei); } } filteredElementId = filteredElementId .Distinct() .ToList(); label1.Content = "Выбрано элементов: " + filteredElementId.Count; } }
/// <summary> /// When the roof was edited, then the data of the RoofItem should be updated synchronously. /// </summary> /// <returns>Update successfully return true, otherwise return false.</returns> public bool Update() { try { this.SubItems[1].Text = m_roof.Name; if (m_roof is Autodesk.Revit.DB.FootPrintRoof) { Parameter para = m_roof.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.ROOF_BASE_LEVEL_PARAM); this.SubItems[2].Text = LevelConverter.GetLevelByID(para.AsElementId().IntegerValue).Name; } else if (m_roof is Autodesk.Revit.DB.ExtrusionRoof) { Parameter para = m_roof.get_Parameter(Autodesk.Revit.DB.BuiltInParameter.ROOF_CONSTRAINT_LEVEL_PARAM); this.SubItems[2].Text = LevelConverter.GetLevelByID(para.AsElementId().IntegerValue).Name; } this.SubItems[3].Text = m_roof.RoofType.Name; } catch { return(false); } return(true); }
//***********************************GetParameterValue*********************************** public string GetParameterValue(Parameter parameter) { switch (parameter.StorageType) { case StorageType.Double: //get value with unit, AsDouble() can get value without unit return(parameter.AsValueString()); case StorageType.ElementId: return(parameter.AsElementId().IntegerValue.ToString()); case StorageType.Integer: //get value with unit, AsInteger() can get value without unit return(parameter.AsValueString()); case StorageType.None: return(parameter.AsValueString()); case StorageType.String: return(parameter.AsString()); default: return(""); } }
object GetParameterValue(Parameter par) { object parValue = null; if (!par.HasValue) { return(parValue); } switch (par.StorageType) { case StorageType.Double: parValue = par.AsDouble(); break; case StorageType.Integer: parValue = par.AsInteger(); break; case StorageType.String: parValue = par.AsString(); break; case StorageType.ElementId: parValue = par.AsElementId(); break; default: break; } return(parValue); }
/// <summary> /// Return parameter value formatted as string /// </summary> static string ParameterToString(Parameter p) { string s = "null"; if (p != null) { switch (p.StorageType) { case StorageType.Double: s = p.AsDouble().ToString("0.##"); break; case StorageType.Integer: s = p.AsInteger().ToString(); break; case StorageType.String: s = p.AsString(); break; case StorageType.ElementId: s = p.AsElementId().IntegerValue.ToString(); break; case StorageType.None: s = "none"; break; } } return(s); }
private Level GetlevelFromOpening() { if (Common.IsValidGuid(_comparisonCoupleElement.IdRevitElement)) { Element element = _doc.GetElement(_comparisonCoupleElement.IdRevitElement); if (element == null) { return(null); } if (element is Opening) { Opening opening = element as Opening; Parameter parameter = opening.LookupParameter("Base Constraint"); Level level = _doc.GetElement(parameter.AsElementId()) as Level; return(level); } else { Level level = _doc.GetElement(element.LevelId) as Level; if (level == null) { XYZ locationPoint = (element.Location as LocationPoint).Point; level = GetLevelFromLocation(_comparisonCoupleElement.LocalGeometry); } return(level); } } else { return(GetLevelFromLocation(_comparisonCoupleElement.ServerGeometry)); } }
/// <summary> /// /// </summary> /// <param name="p"></param> /// <returns></returns> public static object GetParameterValue(Parameter p) { switch (p.StorageType) { case StorageType.None: throw new System.ArgumentOutOfRangeException(); case StorageType.Integer: // (Konrad) It appears that by default yes/no parameters // have a greyed out box checked to 1 even though stored // integer value would return 0 return(p.HasValue ? p.AsInteger() : 1); case StorageType.Double: return(p.AsDouble()); case StorageType.String: return(p.AsString()); case StorageType.ElementId: return(p.AsElementId().IntegerValue); default: throw new System.ArgumentOutOfRangeException(); } }
/// <summary> /// Returns a string value corresponding to an ElementId Parameter. /// </summary> /// <param name="parameter">The parameter.</param> /// <returns>The string.</returns> public static string ElementIdParameterAsString(Parameter parameter) { ElementId value = parameter.AsElementId(); if (value == ElementId.InvalidElementId) return null; string valueString = null; // All real elements in Revit have non-negative ids. if (value.IntegerValue >= 0) { // Get the family and element name. Element paramElement = ExporterCacheManager.Document.GetElement(value); valueString = (paramElement != null) ? paramElement.Name : null; if (!string.IsNullOrEmpty(valueString)) { ElementType paramElementType = paramElement is ElementType ? paramElement as ElementType : ExporterCacheManager.Document.GetElement(paramElement.GetTypeId()) as ElementType; string paramElementTypeName = (paramElementType != null) ? ExporterIFCUtils.GetFamilyName(paramElementType) : null; if (!string.IsNullOrEmpty(paramElementTypeName)) valueString = paramElementTypeName + ": " + valueString; } } else { valueString = parameter.AsValueString(); } if (string.IsNullOrEmpty(valueString)) valueString = value.ToString(); return valueString; }
private static Value _getParam(FamilyInstance fi, Parameter p) { if (p.StorageType == StorageType.Double) { switch (p.Definition.ParameterType) { case ParameterType.Length: return Value.NewContainer(Units.Length.FromFeet(p.AsDouble())); break; case ParameterType.Area: return Value.NewContainer(Units.Area.FromSquareFeet(p.AsDouble())); break; case ParameterType.Volume: return Value.NewContainer(Units.Volume.FromCubicFeet(p.AsDouble())); break; default: return Value.NewNumber(p.AsDouble()); break; } } else if (p.StorageType == StorageType.Integer) { return Value.NewNumber(p.AsInteger()); } else if (p.StorageType == StorageType.String) { return Value.NewString(p.AsString()); } else { return Value.NewContainer(p.AsElementId()); } }
private static Expression _getParam(FamilyInstance fi, Parameter p) { if (p.StorageType == StorageType.Double) { return Expression.NewNumber(p.AsDouble()); } else if (p.StorageType == StorageType.Integer) { return Expression.NewNumber(p.AsInteger()); } else if (p.StorageType == StorageType.String) { return Expression.NewString(p.AsString()); } else { return Expression.NewContainer(p.AsElementId()); } }
// jeremy //public static Object GetParameterValue(Parameter parameter) // jeremy /// <summary> /// get parameter's value /// </summary> /// <param name="parameter">parameter of Element</param> /// <returns>parameter's value include unit if have</returns> public static string GetParameterValue(Parameter parameter) { switch (parameter.StorageType) { case StorageType.Double: //get value with unit, AsDouble() can get value without unit return parameter.AsValueString(); case StorageType.ElementId: return parameter.AsElementId().IntegerValue.ToString(); case StorageType.Integer: //get value with unit, AsInteger() can get value without unit return parameter.AsValueString(); case StorageType.None: return parameter.AsValueString(); case StorageType.String: return parameter.AsString(); default: return ""; } }
/// <summary> /// Helper function: return a string form of a given parameter. /// </summary> public static string ParameterToString(Parameter param) { string val = "none"; if (param == null) { return val; } // To get to the parameter value, we need to pause it depending on its storage type switch (param.StorageType) { case StorageType.Double: double dVal = param.AsDouble(); val = dVal.ToString(); break; case StorageType.Integer: int iVal = param.AsInteger(); val = iVal.ToString(); break; case StorageType.String: string sVal = param.AsString(); val = sVal; break; case StorageType.ElementId: ElementId idVal = param.AsElementId(); val = idVal.IntegerValue.ToString(); break; case StorageType.None: break; } return val; }
private void Stream(ArrayList data, Parameter param) { data.Add(new Snoop.Data.ClassSeparator(typeof(Parameter))); data.Add(new Snoop.Data.Object("Definition", param.Definition)); try { // this only works for certain types of Parameters data.Add(new Snoop.Data.String("Display unit type", param.DisplayUnitType.ToString())); } catch (System.Exception) { data.Add(new Snoop.Data.String("Display unit type", "N/A")); } try { // this only works for certain types of Parameters data.Add(new Snoop.Data.Object("Element", param.Element)); } catch (System.Exception ex) { data.Add(new Snoop.Data.Exception("Element", ex)); } try { // this only works for certain types of Parameters data.Add(new Snoop.Data.String("GUID", param.GUID.ToString())); } catch (System.Exception ex) { data.Add(new Snoop.Data.Exception("GUID", ex)); } try { // this only works for certain types of Parameters data.Add(new Snoop.Data.Bool("HasValue", param.HasValue)); } catch (System.Exception ex) { data.Add(new Snoop.Data.Exception("HasValue", ex)); } try { // this only works for certain types of Parameters data.Add(new Snoop.Data.ElementId("ID", param.Id,m_activeDoc)); } catch (System.Exception ex) { data.Add(new Snoop.Data.Exception("ID", ex)); } try { // this only works for certain types of Parameters data.Add(new Snoop.Data.Bool("IsShared", param.IsShared)); } catch (System.Exception ex) { data.Add(new Snoop.Data.Exception("IsShared", ex)); } data.Add(new Snoop.Data.String("Storage type", param.StorageType.ToString())); if (param.StorageType == StorageType.Double) data.Add(new Snoop.Data.Double("Value", param.AsDouble())); else if (param.StorageType == StorageType.ElementId) data.Add(new Snoop.Data.ElementId("Value", param.AsElementId(), m_app.ActiveUIDocument.Document)); else if (param.StorageType == StorageType.Integer) data.Add(new Snoop.Data.Int("Value", param.AsInteger())); else if (param.StorageType == StorageType.String) data.Add(new Snoop.Data.String("Value", param.AsString())); data.Add(new Snoop.Data.String("As value string", param.AsValueString())); }
/// <summary> /// Helper to return parameter value as string, with additional /// support for element id to display the element type referred to. /// </summary> public static string GetParameterValue2( Parameter param, Document doc ) { string s; if( StorageType.ElementId == param.StorageType && null != doc ) { ElementId id = param.AsElementId(); int i = id.IntegerValue; if( 0 > i ) { s = i.ToString() + BuiltInCategoryString( i ); } else { Element e = doc.GetElement( id ); s = ElementDescription( e, true ); } } else { s = GetParameterValue( param ); } return s; }
/// <summary> /// Helper to return parameter value as string. /// One can also use param.AsValueString() to /// get the user interface representation. /// </summary> public static string GetParameterValue( Parameter param ) { string s; switch( param.StorageType ) { case StorageType.Double: // // the internal database unit for all lengths is feet. // for instance, if a given room perimeter is returned as // 102.36 as a double and the display unit is millimeters, // then the length will be displayed as // peri = 102.36220472440 // peri * 12 * 25.4 // 31200 mm // //s = param.AsValueString(); // value seen by user, in display units //s = param.AsDouble().ToString(); // if not using not using LabUtils.RealString() s = RealString( param.AsDouble() ); // raw database value in internal units, e.g. feet break; case StorageType.Integer: s = param.AsInteger().ToString(); break; case StorageType.String: s = param.AsString(); break; case StorageType.ElementId: s = param.AsElementId().IntegerValue.ToString(); break; case StorageType.None: s = "?NONE?"; break; default: s = "?ELSE?"; break; } return s; }
private static FScheme.Value _getParam(FamilySymbol fi, Parameter p) { if (p.StorageType == StorageType.Double) { return FScheme.Value.NewNumber(p.AsDouble()); } else if (p.StorageType == StorageType.Integer) { return FScheme.Value.NewNumber(p.AsInteger()); } else if (p.StorageType == StorageType.String) { return FScheme.Value.NewString(p.AsString()); } else { return FScheme.Value.NewContainer(p.AsElementId()); } }
private static Value _getParam(Parameter p) { switch (p.StorageType) { case StorageType.ElementId: return Value.NewContainer(p.AsElementId()); case StorageType.String: return Value.NewString(p.AsString()); case StorageType.Integer: case StorageType.Double: switch (p.Definition.ParameterType) { case ParameterType.Length: return Value.NewContainer(Units.Length.FromFeet(p.AsDouble(), dynSettings.Controller.UnitsManager)); case ParameterType.Area: return Value.NewContainer(Units.Area.FromSquareFeet(p.AsDouble(), dynSettings.Controller.UnitsManager)); case ParameterType.Volume: return Value.NewContainer(Units.Volume.FromCubicFeet(p.AsDouble(), dynSettings.Controller.UnitsManager)); default: return Value.NewNumber(p.AsDouble()); } default: throw new Exception(string.Format("Parameter {0} has no storage type.", p)); } }
private void writeValueByStorageType(Parameter p, TextWriter writer, Document doc) { if (null != p) { switch (p.StorageType) { case StorageType.Double: { writer.Write(p.AsDouble()); break; } case StorageType.Integer: { writer.Write(p.AsInteger()); break; } case StorageType.String: { writer.Write(p.AsString()); break; } case StorageType.ElementId: { Element elem = doc.get_Element(p.AsElementId()); if (null == elem) writer.Write("NULL ELEMENT FOUND"); else writer.Write(elem.Name); break; } default: writer.Write("N/A"); break; } } }
/// <summary> /// Extract the parameter information. /// By Dan Tartaglia. /// </summary> public string GetParameterInformation( Parameter para, Document doc) { string defName = ""; // Use different method to get parameter // data according to the storage type switch( para.StorageType ) { // Determine the parameter type case StorageType.Double: // Convert the number into Metric defName = para.AsValueString(); break; case StorageType.ElementId: // Find out the name of the element Autodesk.Revit.DB.ElementId id = para.AsElementId(); defName = ( id.IntegerValue >= 0 ) ? doc.GetElement( id ).Name : id.IntegerValue.ToString(); break; case StorageType.Integer: if( ParameterType.YesNo == para.Definition.ParameterType ) { if( para.AsInteger() == 0 ) { defName = "False"; } else { defName = "True"; } } else { defName = para.AsInteger().ToString(); } break; case StorageType.String: defName = para.AsString(); break; default: defName = "Unexposed parameter"; break; } return defName; }