/***************************************************/ public static ElementType ToRevitElementType(this ClonedType clonedType, Document document, RevitSettings settings = null, Dictionary <Guid, List <int> > refObjects = null) { ElementType elementType = refObjects.GetValue <ElementType>(document, clonedType.BHoM_Guid); if (elementType != null) { return(elementType); } settings = settings.DefaultIfNull(); Element source = document.GetElement(new ElementId(clonedType.SourceTypeId)); if (source == null) { BH.Engine.Reflection.Compute.RecordError($"The element with ElementId {clonedType.SourceTypeId} does not exist in the active Revit document."); return(null); } ElementType sourceType = source as ElementType; if (sourceType == null) { BH.Engine.Reflection.Compute.RecordError($"The element with ElementId {clonedType.SourceTypeId} exists in the active Revit document, but it is not an element type."); return(null); } elementType = sourceType.Duplicate(clonedType.Name); // Copy parameters from BHoM object to Revit element elementType.CopyParameters(clonedType, settings); refObjects.AddOrReplace(clonedType, elementType); return(elementType); }
/// <summary> /// duplicate one FamilySymbol and add to lists /// </summary> /// <param name="framingSymbol">FamilySymbol to be copied</param> /// <param name="symbolName">duplicate FamilySymbol's Name</param> /// <returns>new FamilySymbol</returns> public FamilySymbol DuplicateSymbol(ElementType framingSymbol, string symbolName) { // duplicate a FamilySymbol ElementType symbol = framingSymbol.Duplicate(GenerateSymbolName(symbolName)); FamilySymbol result = symbol as FamilySymbol; if (null != result) { // add to lists m_symbolMaps.Add(result.Name, result); m_symbols.Add(result); } return(result); }
public static ElementType DuplicateByType(this Document document, PanelType panelType_New, Construction construction_New) { if (construction_New == null || document == null) { return(null); } FilteredElementCollector filteredElementCollector = Query.FilteredElementCollector(document, panelType_New); if (filteredElementCollector == null) { return(null); } List <ElementType> elementTypes = filteredElementCollector.OfClass(typeof(ElementType)).Cast <ElementType>().ToList(); if (elementTypes == null || elementTypes.Count == 0) { return(null); } ElementType elementType = elementTypes.Find(x => x.Name.Equals(construction_New.Name)); if (elementType == null) { Construction construction = Analytical.Query.DefaultConstruction(panelType_New); if (construction == null) { return(null); } ElementType elementType_ToBeDuplicated = elementTypes.Find(x => x.Name.Equals(construction.Name)); if (elementType_ToBeDuplicated == null) { return(null); } elementType = elementType_ToBeDuplicated.Duplicate(construction_New.Name); } if (elementType == null) { return(null); } Core.Revit.Modify.SetValues(elementType, construction_New); Core.Revit.Modify.SetValues(elementType, construction_New, ActiveSetting.Setting); return(elementType); }
public static ElementType DuplicateByType(this Document document, string name_Old, ApertureConstruction apertureConstruction_New) { if (apertureConstruction_New == null || document == null || string.IsNullOrWhiteSpace(name_Old)) { return(null); } BuiltInCategory builtInCategory = apertureConstruction_New.ApertureType.BuiltInCategory(); if (builtInCategory == BuiltInCategory.INVALID) { return(null); } List <ElementType> elementTypes = new FilteredElementCollector(document).OfClass(typeof(ElementType)).OfCategory(builtInCategory).Cast <ElementType>().ToList(); if (elementTypes == null || elementTypes.Count == 0) { return(null); } ElementType elementType = elementTypes.Find(x => x.Name.Equals(apertureConstruction_New.Name)); if (elementType == null) { ElementType elementType_ToBeDuplicated = elementTypes.Find(x => x.Name.Equals(name_Old)); if (elementType_ToBeDuplicated == null) { return(null); } elementType = elementType_ToBeDuplicated.Duplicate(apertureConstruction_New.Name); } if (elementType == null) { return(null); } Core.Revit.Modify.SetValues(elementType, apertureConstruction_New); Core.Revit.Modify.SetValues(elementType, apertureConstruction_New, ActiveSetting.Setting); return(elementType); }
public static ElementType DuplicateByName(this Document document, string name_Old, BuiltInCategory builtInCategory, SAMType sAMType_New, IEnumerable <string> parameterNames = null) { if (sAMType_New == null || document == null || string.IsNullOrWhiteSpace(name_Old) || builtInCategory == BuiltInCategory.INVALID) { return(null); } string name_New = sAMType_New.Name; if (string.IsNullOrWhiteSpace(name_New)) { return(null); } List <ElementType> elementTypes = new FilteredElementCollector(document).OfClass(typeof(ElementType)).OfCategory(builtInCategory).Cast <ElementType>().ToList(); if (elementTypes == null || elementTypes.Count == 0) { return(null); } ElementType elementType = elementTypes.Find(x => x.Name.Equals(name_New)); if (elementType == null) { ElementType elementType_ToBeDuplicated = elementTypes.Find(x => x.Name.Equals(name_Old)); if (elementType_ToBeDuplicated == null) { return(null); } elementType = elementType_ToBeDuplicated.Duplicate(name_New); } if (elementType == null) { return(null); } SetValues(elementType, sAMType_New, parameterNames); return(elementType); }
private ElementType CreateTrimType(ElementType type, string trimCol, string shutCol) { List <Material> materialElements = _doc.CollectElements <Material>(BuiltInCategory.OST_Materials); string newTypeName = $"{type.FamilyName}-{trimCol}-{shutCol}"; _tt.Start(); ElementType newTrimType = type.Duplicate(newTypeName); // Retrieving the materials to match the desired type Material trimMat = null; Material shutterMat = null; foreach (Material material in materialElements.Where(material => material.Name.Contains("Wood"))) { if (material.Name.Contains(trimCol)) { trimMat = material; } if (material.Name.Contains(shutCol)) { shutterMat = material; } } // Setting the parameters for the new trim type if (trimMat != null) { newTrimType.SetParameter("Material", trimMat.Id); } if (shutterMat != null) { newTrimType.SetParameter("Shutter Material", shutterMat.Id); } _tt.Commit(); return(newTrimType); }
/// <summary> /// <remarks>郑海盛</remarks> /// 复制type /// </summary> /// <param name="eleid"></param> /// <param name="name"></param> /// <returns></returns> public virtual ElementType CopyFamilySymbol(ElementId eleid, string name) { ElementType eType = this.m_RevitDoc.GetElement(eleid) as ElementType; using (Transaction trans = new Transaction(this.m_RevitDoc)) { try { trans.Start("复制族类型"); var type = eType.Duplicate(name); trans.Commit(); return(type); } catch { trans.RollBack(); return(null); } } }
public void CreateNewTypes() { UIDocument uidoc = ActiveUIDocument; Document doc = uidoc.Document; ElementClassFilter f1 = new ElementClassFilter(typeof(FamilyInstance)); StructuralMaterialTypeFilter f2 = new StructuralMaterialTypeFilter(StructuralMaterialType.Concrete); ElementClassFilter f3 = new ElementClassFilter(typeof(Floor)); ElementClassFilter f4 = new ElementClassFilter(typeof(Wall)); LogicalAndFilter f5 = new LogicalAndFilter(f1, f2); LogicalOrFilter f6 = new LogicalOrFilter(f3, f4); LogicalOrFilter memberFilter = new LogicalOrFilter(f5, f6); FilteredElementCollector collector = new FilteredElementCollector(doc); collector.WherePasses(memberFilter); List <Element> members = collector.ToList(); using (Transaction tx = new Transaction(doc, "MarkFrames")){ tx.Start(); foreach (Element e in members) { Debug.Print(string.Format( "Type '{0}-{1}' listed.", e.get_Parameter(BuiltInParameter.DOOR_NUMBER).AsString(), e.get_Parameter(BuiltInParameter.ELEM_TYPE_PARAM).AsValueString())); try { ElementId eTypeId = e.get_Parameter(BuiltInParameter.ELEM_TYPE_PARAM).AsElementId(); ElementType eType = doc.GetElement(eTypeId) as ElementType; ElementType newEType = eType.Duplicate(string.Format( "{0}-{1}", e.get_Parameter(BuiltInParameter.DOOR_NUMBER).AsString(), e.get_Parameter(BuiltInParameter.ELEM_TYPE_PARAM).AsValueString())) as ElementType; e.get_Parameter(BuiltInParameter.ELEM_TYPE_PARAM).Set(newEType.Id); } catch (Exception) { //throw; } } tx.Commit(); } }
public bool TryRebuildRevitModel(Autodesk.Revit.DB.Document inputDoc, RevitModelRequest inputReqeust, out Autodesk.Revit.DB.Element createdElement) { createdElement = null; try { UseRevitModelRequest useRequest = inputReqeust as UseRevitModelRequest; LineElement line1 = inputReqeust.RequestData.LstCurveElements[0] as LineElement; LineElement line2 = inputReqeust.RequestData.LstCurveElements[1] as LineElement; XYZ midStart, midEnd; double width; if (line1.ThisCurve.Project(line2.ThisCurve.GetEndPoint(0)).XYZPoint.IsAlmostEqualTo(line1.ThisCurve.GetEndPoint(0))) { midStart = (line1.ThisCurve.GetEndPoint(0) + line2.ThisCurve.GetEndPoint(0)) / 2; midEnd = (line1.ThisCurve.GetEndPoint(1) + line2.ThisCurve.GetEndPoint(1)) / 2; width = line1.ThisCurve.GetEndPoint(0).DistanceTo(line2.ThisCurve.GetEndPoint(0)); } else { midStart = (line1.ThisCurve.GetEndPoint(0) + line2.ThisCurve.GetEndPoint(1)) / 2; midEnd = (line1.ThisCurve.GetEndPoint(1) + line2.ThisCurve.GetEndPoint(0)) / 2; width = line1.ThisCurve.GetEndPoint(0).DistanceTo(line2.ThisCurve.GetEndPoint(1)); } Line useMidLine = Line.CreateBound(midStart, midEnd); string useTypeName = inputReqeust.UseTypeName; FilteredElementCollector useCollector = new FilteredElementCollector(inputDoc).OfCategory(BuiltInCategory.OST_Walls).WhereElementIsElementType(); ElementType useElementType = null; foreach (var oneElement in useCollector.ToElements()) { if (oneElement.Name == useTypeName) { useElementType = oneElement as ElementType; break; } } Transaction useTransaction = new Transaction(inputDoc, "creatWall"); useTransaction.Start(); useElementType = useElementType.Duplicate(useTypeName + Guid.NewGuid().ToString()); var useStructure = (useElementType as WallType).GetCompoundStructure(); useStructure.SetLayerWidth(0, width); (useElementType as WallType).SetCompoundStructure(useStructure); createdElement = Wall.Create(inputDoc, useMidLine, (inputDoc.ActiveView as ViewPlan).GenLevel.Id, false); (createdElement as Wall).WallType = useElementType as WallType; useTransaction.Commit(); return(true); } catch (Exception) { return(false); } }
public static ElementType set_elementtype(CompoundStructure compound, ObservableCollection <data_materials> mydata_materials, ObservableCollection <data_parameters> mydata_parameters, ElementType elementType, string CreateOrUpdate, string name_type_new, string unit_length) { ElementType elementType_new = null; try { var TypeOftype = elementType.GetType(); if (CreateOrUpdate == Source.Update) { F_SetCompound.set_compound_structure(compound, mydata_materials, mydata_parameters, unit_length); if (elementType.GetType().Name == "WallType") { var wall_Type = elementType as WallType; wall_Type.SetCompoundStructure(compound); } if (elementType.GetType().Name == "FloorType") { var floor_Type = elementType as FloorType; floor_Type.SetCompoundStructure(compound); } if (elementType.GetType().Name == "RoofType") { var roof_Type = elementType as RoofType; roof_Type.SetCompoundStructure(compound); } if (elementType.GetType().Name == "CeilingType") { var ceiling_Type = elementType as CeilingType; ceiling_Type.SetCompoundStructure(compound); } } else if (CreateOrUpdate == Source.Duplicate) { if (elementType.GetType().Name == "WallType") { var wall_Type = elementType.Duplicate(name_type_new) as WallType; elementType_new = wall_Type; wall_Type.SetCompoundStructure(F_SetCompound.set_compound_structure(wall_Type.GetCompoundStructure(), mydata_materials, mydata_parameters, unit_length)); } if (elementType.GetType().Name == "FloorType") { var floor_Type = elementType.Duplicate(name_type_new) as FloorType; elementType_new = floor_Type; floor_Type.SetCompoundStructure(F_SetCompound.set_compound_structure(floor_Type.GetCompoundStructure(), mydata_materials, mydata_parameters, unit_length)); } if (elementType.GetType().Name == "RoofType") { var roof_Type = elementType.Duplicate(name_type_new) as RoofType; elementType_new = roof_Type; roof_Type.SetCompoundStructure(F_SetCompound.set_compound_structure(roof_Type.GetCompoundStructure(), mydata_materials, mydata_parameters, unit_length)); } if (elementType.GetType().Name == "CeilingType") { var ceiling_Type = elementType.Duplicate(name_type_new) as CeilingType; elementType_new = ceiling_Type; ceiling_Type.SetCompoundStructure(F_SetCompound.set_compound_structure(ceiling_Type.GetCompoundStructure(), mydata_materials, mydata_parameters, unit_length)); } } } catch (Exception ex) { MessageBox.Show(ex.Message); } return(elementType_new); }
const double labelTextOffset = 0.005; // 5mm, defined in paper space #endregion #region InterfaceImplementation /// <summary> /// Implement this method as an external command for Revit. /// </summary> /// <param name="commandData">An object that is passed to the external application /// which contains data related to the command, /// such as the application object and active view.</param> /// <param name="message">A message that can be set by the external application /// which will be displayed if a failure or cancellation is returned by /// the external command.</param> /// <param name="elements">A set of elements to which the external application /// can add elements that are to be highlighted in case of failure or cancellation.</param> /// <returns>Return the status of the external command. /// A result of Succeeded means that the API external method functioned as expected. /// Cancelled can be used to signify that the user cancelled the external operation /// at some point. Failure should be returned if the application is unable to proceed with /// the operation.</returns> public virtual Result Execute(ExternalCommandData commandData , ref string message, ElementSet elements) { try { Document document = commandData.Application.ActiveUIDocument.Document; Autodesk.Revit.DB.View view = commandData.View; // find major and minor station arrow styles FilteredElementCollector fec = new FilteredElementCollector(document); Element majorStationLeaderArrowheadType = fec.OfClass(typeof(ElementType)) .Cast <ElementType>() .FirstOrDefault(x => x.Name.Contains(majorStationLeaderArrowheadName)); Element minorStationLeaderArrowheadType = fec.OfClass(typeof(ElementType)) .Cast <ElementType>() .FirstOrDefault(x => x.Name.Contains(minorStationLeaderArrowheadName)); if (majorStationLeaderArrowheadType == null || minorStationLeaderArrowheadType == null) { TaskDialog td = new TaskDialog("Missing arrowheads"); td.MainContent = "In Manage>Additional Settings>Arrowheads, create two styles of arrowheads, named\r\n" + "Major Station Arrowhead and Minor Station Arrowhead"; td.Show(); return(Result.Failed); } // find major and minor station label types; if not there, create them SpotDimensionType majorLabelType = fec.OfClass(typeof(SpotDimensionType)) .Cast <SpotDimensionType>() .FirstOrDefault(sdt => sdt.StyleType == DimensionStyleType.AlignmentStationLabel && sdt.Name.Contains(majorStationSetLabelTypeName)); SpotDimensionType minorLabelType = fec.OfClass(typeof(SpotDimensionType)) .Cast <SpotDimensionType>() .FirstOrDefault(sdt => sdt.StyleType == DimensionStyleType.AlignmentStationLabel && sdt.Name.Contains(minorStationSetLabelTypeName)); SpotDimensionType curvatureLabelType = fec.OfClass(typeof(SpotDimensionType)) .Cast <SpotDimensionType>() .FirstOrDefault(sdt => sdt.StyleType == DimensionStyleType.AlignmentStationLabel && sdt.Name.Contains(horizontalCurvatureChangeLabelTypeName)); using (Transaction t = new Transaction(document, "Create major station labels")) { t.Start(); if (majorLabelType == null) { // create major station label type with the given arrowhead style majorLabelType = document.GetElement(AlignmentStationLabel.CreateRecommendedTypeForSet(document)) as SpotDimensionType; majorLabelType.get_Parameter(BuiltInParameter.SPOT_ELEV_LEADER_ARROWHEAD).Set(majorStationLeaderArrowheadType.Id); majorLabelType.Name = majorStationSetLabelTypeName; } if (minorLabelType == null) { // create minor station label type with the given arrowhead style // exclude the station text, which leave only the arrowheads // make the minor station's color grey // make the text 60% of the original value, in case text is later turned on minorLabelType = document.GetElement(AlignmentStationLabel.CreateRecommendedTypeForSet(document)) as SpotDimensionType; minorLabelType.get_Parameter(BuiltInParameter.SPOT_ELEV_LEADER_ARROWHEAD).Set(minorStationLeaderArrowheadType.Id); minorLabelType.get_Parameter(BuiltInParameter.ALIGNMENT_STATION_LABEL_INCLUDE_STATION).Set(0); minorLabelType.get_Parameter(BuiltInParameter.LINE_COLOR).Set(8421504 /* 127*2^0 + 127*2^8 + 127*2^16: grey */); Parameter textSizeParam = minorLabelType.get_Parameter(BuiltInParameter.TEXT_SIZE); textSizeParam.Set(textSizeParam.AsDouble() * 0.6); minorLabelType.Name = minorStationSetLabelTypeName; } if (curvatureLabelType == null) { // create a new label type, based on the default alignment station label type, // but with some adjustments to the label contents, as described below ElementType defaultAlignmentLabelType = document.GetElement( document.GetDefaultElementTypeId(ElementTypeGroup.AlignmentStationLabelType)) as ElementType; curvatureLabelType = defaultAlignmentLabelType.Duplicate(horizontalCurvatureChangeLabelTypeName) as SpotDimensionType; curvatureLabelType.get_Parameter(BuiltInParameter.SPOT_COORDINATE_BASE).Set(1); // "Shared" coordinate base // Label position and content curvatureLabelType.get_Parameter(BuiltInParameter.SPOT_ELEV_ROTATE_WITH_COMPONENT).Set(0); // do not rotate with component curvatureLabelType.get_Parameter(BuiltInParameter.SPOT_ELEV_TEXT_ORIENTATION).Set(0); // horizontal text curvatureLabelType.get_Parameter(BuiltInParameter.SPOT_ELEV_TEXT_LOCATION).Set(0); // text location above leader curvatureLabelType.get_Parameter(BuiltInParameter.ALIGNMENT_STATION_LABEL_INCLUDE_STATION).Set(1); // include station curvatureLabelType.get_Parameter(BuiltInParameter.SPOT_COORDINATE_INCLUDE_ELEVATION).Set(0); // do not include elevation curvatureLabelType.get_Parameter(BuiltInParameter.SPOT_ELEV_BOT_VALUE).Set(0); // do not include bottom value curvatureLabelType.get_Parameter(BuiltInParameter.SPOT_ELEV_TOP_VALUE).Set(0); // do not include top value curvatureLabelType.get_Parameter(BuiltInParameter.ALIGNMENT_STATION_LABEL_IND_STATION).Set(""); // empty station indicator // Text curvatureLabelType.get_Parameter(BuiltInParameter.DIM_TEXT_BACKGROUND).Set(0); // nontransparent text curvatureLabelType.get_Parameter(BuiltInParameter.LINE_COLOR).Set(255 /* 255*2^0 + 0*2^8 + 0*2^16: red */); // text in red color Parameter textSizeParam = curvatureLabelType.get_Parameter(BuiltInParameter.TEXT_SIZE); textSizeParam.Set(textSizeParam.AsDouble() * 0.6); // text size 60% of default // Leader curvatureLabelType.get_Parameter(BuiltInParameter.SPOT_ELEV_LEADER_ARROWHEAD).Set(ElementId.InvalidElementId); // no leader arrowhead } t.Commit(); } // create major and minor station label sets ElementId alignmentId = AlignmentSelectionFilter.SelectAlignment(document); Alignment alignment = Alignment.Get(document.GetElement(alignmentId)); // start placement from a multiple of the major station interval // make sure to compute the multiple in the proper unit system and then convert it back to internal units for further use double labelSetsPlacementStartStation = UnitUtils.ConvertFromInternalUnits(alignment.DisplayedStartStation, UnitTypeId.StationingMeters); labelSetsPlacementStartStation = Math.Ceiling(labelSetsPlacementStartStation / majorStationInterval) * majorStationInterval; labelSetsPlacementStartStation = UnitUtils.ConvertToInternalUnits(labelSetsPlacementStartStation, UnitTypeId.StationingMeters); var majorStations = new List <double>(); using (Transaction t = new Transaction(document, "Create major station labels")) { t.Start(); AlignmentStationLabelSetOptions options = new AlignmentStationLabelSetOptions(); options.Interval = UnitUtils.ConvertToInternalUnits(majorStationInterval, UnitTypeId.StationingMeters); options.Offset = UnitUtils.ConvertToInternalUnits(labelTextOffset, UnitTypeId.StationingMeters); options.StartStation = labelSetsPlacementStartStation; options.EndStation = alignment.DisplayedEndStation; options.TypeId = majorLabelType.Id; var labels = AlignmentStationLabel.CreateSet(alignment, view, options); foreach (var label in labels) { majorStations.Add(label.Station); } t.Commit(); } using (Transaction t = new Transaction(document, "Create minor station labels")) { t.Start(); AlignmentStationLabelSetOptions options = new AlignmentStationLabelSetOptions(); options.Interval = UnitUtils.ConvertToInternalUnits(minorStationInterval, UnitTypeId.StationingMeters); // setting text offset specification can be skipped, // as in this example the minor station labels do not include any label text, only leader arrowheads options.StartStation = labelSetsPlacementStartStation; options.EndStation = labelSetsPlacementStartStation + UnitUtils.ConvertToInternalUnits(majorStationInterval, UnitTypeId.StationingMeters); options.TypeId = minorLabelType.Id; // delete the minor station labels which overlap with the major ones var labels = AlignmentStationLabel.CreateSet(alignment, view, options); foreach (var label in labels) { foreach (var majorStation in majorStations) { if (MathComparisonUtils.IsAlmostEqual(label.Station, majorStation)) { label.Element.Pinned = false; document.Delete(label.Element.Id); break; } } } t.Commit(); } if (view.ViewType == ViewType.FloorPlan || view.ViewType == ViewType.CeilingPlan || view.ViewType == ViewType.EngineeringPlan) { IList <HorizontalCurveEndpoint> curveEndpoints = alignment.GetDisplayedHorizontalCurveEndpoints(); using (TransactionGroup tg = new TransactionGroup(document, "Create horizontal curvature changes labels")) { tg.Start(); double previousStation = alignment.DisplayedStartStation; foreach (var curveEndpoint in curveEndpoints) { using (Transaction t = new Transaction(document, "Create one horizontal curvature change label")) { double thisStation = curveEndpoint.Station; // skip placing curvature labels at the start and end points of the alignment if (MathComparisonUtils.IsAlmostEqual((alignment.DisplayedStartStation), thisStation) || MathComparisonUtils.IsAlmostEqual((alignment.DisplayedEndStation), thisStation)) { continue; } t.Start(); AlignmentStationLabelOptions options = new AlignmentStationLabelOptions(thisStation); options.HasLeader = false; options.TypeId = curvatureLabelType.Id; AlignmentStationLabel label = AlignmentStationLabel.Create(alignment, view, options); // regeneration is necessary before the label's positional properties (such as Origin)L can be properly evaluated document.Regenerate(); // set the shoulder and end to coincide, creating a leader pointing along the view's up direction SpotDimension dim = label.Element as SpotDimension; XYZ leaderDirection = view.UpDirection; // compute the distance to the previous label // if the previous label is too close, flip the placement direction { var dimBBox = dim.get_BoundingBox(view); double dimOffset = Math.Abs(dimBBox.Max.X - dimBBox.Min.X); if (MathComparisonUtils.IsGreaterThanOrAlmostEqual(dimOffset, thisStation - previousStation)) { leaderDirection = leaderDirection.Negate(); } } dim.HasLeader = true; dim.LeaderHasShoulder = true; dim.LeaderShoulderPosition = dim.Origin + leaderDirection * UnitUtils.ConvertToInternalUnits(labelTextOffset, UnitTypeId.StationingMeters) * view.Scale; dim.LeaderEndPosition = dim.LeaderShoulderPosition; dim.TextPosition = dim.LeaderShoulderPosition; previousStation = thisStation; t.Commit(); } } tg.Assimilate(); } } return(Result.Succeeded); } catch (Exception ex) { message = ex.Message; return(Result.Failed); } }
protected virtual Element CreateNewElement(DataRow row) { // *** Coyove Patched *** Element result; try { string text = APIObjectList.ColumnRes((BuiltInParameter)(-1002002)); string text2 = APIObjectList.ColumnRes((BuiltInParameter)(-1002001)); string text3 = row[text].ToString(); string text4 = row[text2].ToString(); if (text3 == null || text4 == null || text3 == string.Empty || text4 == string.Empty) { result = null; } else { string arg = text4; while (true) { string text5 = text4.Replace("'", "''"); string text6 = text3.Replace("'", "''"); // string filterExpression = string.Format("[{0}] = '{1}' and [{2}] = '{3}'", new object[] string filterExpression = string.Format("\"{0}\" = '{1}' and \"{2}\" = '{3}'", new object[] { text, text6, text2, text5 }); if (row.Table.Select(filterExpression).Length <= 1) { break; } text4 = arg + " " + this.m_numberSuffix; Utility.Assign(row, text2, text4); this.m_numberSuffix++; } Element element = null; foreach (Element element2 in base.Elements) { if (element == null) { element = element2; } Parameter parameter = element2.get_Parameter((BuiltInParameter)(-1002002)); if (parameter != null && parameter.AsString().Equals(text3)) { element = element2; break; } } if (element == null) { result = null; } else { ElementType elementType = element as ElementType; Element element3 = elementType.Duplicate(text4); base.Elements.Insert(element3); row[base.TableInfo[base.TableInfo.PrimaryKeys[0]].Name] = element3.Id.IntegerValue; result = element3; } } } catch { result = null; } return(result); }
/// <summary> /// duplicate one FamilySymbol and add to lists /// </summary> /// <param name="framingSymbol">FamilySymbol to be copied</param> /// <param name="symbolName">duplicate FamilySymbol's Name</param> /// <returns>new FamilySymbol</returns> public FamilySymbol DuplicateSymbol(ElementType framingSymbol, string symbolName) { // duplicate a FamilySymbol ElementType symbol = framingSymbol.Duplicate(GenerateSymbolName(symbolName)); FamilySymbol result = symbol as FamilySymbol; if (null != result) { // add to lists m_symbolMaps.Add(result.Name, result); m_symbols.Add(result); } return result; }