private void moveLinkedFiles(Document doc) { FilteredElementCollector collector = new FilteredElementCollector(doc); collector .OfCategory(BuiltInCategory.OST_RvtLinks) .OfClass(typeof(RevitLinkInstance)); WorksetTable worksetTable = doc.GetWorksetTable(); FilteredWorksetCollector coll = new FilteredWorksetCollector(doc); //StringBuilder worksetNames = new StringBuilder(); //foreach (Workset workset in coll) //{ // worksetNames.AppendFormat("{0}: {1}\n", workset.Name, workset.Kind); //} //TaskDialog.Show("Worksets", worksetNames.ToString()); foreach (Element ele in collector) { string searchString = ele.Name; Match result = Regex.Match(searchString, @"^.*?(?=_)"); Parameter wsparam = ele.get_Parameter(BuiltInParameter.ELEM_PARTITION_PARAM); //Workset matchingWorkset = null; foreach (Workset workset in coll) { string worksetName = workset.Name; Match result2 = Regex.Match(worksetName, @"^.*?(?=\s)"); if (result.ToString() == result2.ToString()) { using (Transaction tx = new Transaction(doc)) { tx.Start("Change workset id"); wsparam.Set(workset.Id.IntegerValue); tx.Commit(); } } } } }
/// <summary> /// Publishes Workset Open Data to database for onOpened/onSynched events. /// </summary> /// <param name="doc">Revit Document.</param> /// <param name="filePath">Revit Document central file path.</param> /// <param name="state">State of the Revit model.</param> public void PublishData(Document doc, string filePath, WorksetMonitorState state) { try { var worksets = new FilteredWorksetCollector(doc) .OfKind(WorksetKind.UserWorkset) .ToWorksets(); var opened = 0; var closed = 0; foreach (var w in worksets) { if (w.IsOpen) { opened++; } else { closed++; } } var worksetInfo = new WorksetEvent { CentralPath = filePath.ToLower(), User = Environment.UserName.ToLower(), Opened = opened, Closed = closed }; var route = state == WorksetMonitorState.onopened ? "onopened" : "onsynched"; if (!ServerUtilities.Post(worksetInfo, "worksets/" + route, out WorksetEvent unused)) { Log.AppendLog(LogMessageType.ERROR, "Failed to publish Worksets Data: " + state + "."); } } catch (Exception ex) { Log.AppendLog(LogMessageType.EXCEPTION, ex.Message); } }
/***************************************************/ /**** Public methods ****/ /***************************************************/ public static IEnumerable <WorksetId> OpenWorksetIds(this Document document) { if (document == null) { return(null); } FilteredWorksetCollector filteredWorksetCollector = new FilteredWorksetCollector(document).OfKind(WorksetKind.UserWorkset); List <WorksetId> result = new List <WorksetId>(); foreach (Workset workset in filteredWorksetCollector) { if (workset.IsOpen) { result.Add(workset.Id); } } return(result); }
/// <summary> /// Retrieves the workset with the given name. /// </summary> /// <param name="name">A workset name</param> /// <returns name="workset">Returns a workset. Returns null if workset does not exist.</returns> public static Workset GetByName(string name) { Workset foundWorkset = null; if (name != null) { //Get Revit Document object revitDoc doc = DocumentManager.Instance.CurrentDBDocument; FilteredWorksetCollector fwCollector = new FilteredWorksetCollector(doc); foreach (revitWorkset workset in fwCollector) { if (workset.Name == name) { foundWorkset = new Workset(doc, workset); } } fwCollector.Dispose(); } return(foundWorkset); }
private void GetWorksets() { try { if (sModelInfo.ModelDoc.IsWorkshared) { var collector = new FilteredWorksetCollector(sModelInfo.ModelDoc); var wsFilter = new WorksetKindFilter(WorksetKind.UserWorkset); var worksets = collector.WherePasses(wsFilter).ToWorksets().ToList(); foreach (var ws in worksets) { var iInfo = new ItemInfo(ws, MapType.Workset); if (!sourceItems.ContainsKey(iInfo.ItemId)) { sourceItems.Add(iInfo.ItemId, iInfo); } } } if (rModelInfo.ModelDoc.IsWorkshared) { var collector = new FilteredWorksetCollector(rModelInfo.ModelDoc); var wsFilter = new WorksetKindFilter(WorksetKind.UserWorkset); var worksets = collector.WherePasses(wsFilter).ToWorksets().ToList(); foreach (var ws in worksets) { var iInfo = new ItemInfo(ws, MapType.Workset); if (!recipientItems.ContainsKey(iInfo.ItemId)) { recipientItems.Add(iInfo.ItemId, iInfo); } } } } catch (Exception ex) { MessageBox.Show("Failed to get worksets.\n" + ex.Message, "Get Worksets", MessageBoxButton.OK, MessageBoxImage.Warning); } }
public void Execute(UpdaterData data) { Document doc = data.GetDocument(); foreach (ElementId addedElementId in data.GetAddedElementIds()) { Element elem = doc.GetElement(addedElementId); Parameter wsparam = elem.get_Parameter(BuiltInParameter.ELEM_PARTITION_PARAM); //find all user's workset FilteredWorksetCollector worksets = new FilteredWorksetCollector(doc).OfKind(WorksetKind.UserWorkset); if (worksets != null) { foreach (Workset ws in worksets) { if (ws.Name == "共享标高和轴网" || ws.Name == "Shared Levels and Grids") { wsparam.Set(ws.Id.IntegerValue); } } } } }
public Workset GetWorkset(Document doc) { IList <Workset> userWorksets = new FilteredWorksetCollector(doc) .OfKind(WorksetKind.UserWorkset) .ToWorksets(); bool checkNotExists = WorksetTable.IsWorksetNameUnique(doc, WorksetName); if (!checkNotExists) { Workset wset = new FilteredWorksetCollector(doc) .OfKind(WorksetKind.UserWorkset) .ToWorksets() .Where(w => w.Name == WorksetName) .First(); return(wset); } else { Workset wset = Workset.Create(doc, WorksetName); return(wset); } }
private void MyWorksetExplorer(UIDocument UIdoc) { Document _doc = UIdoc.Document; // Выборка всех элементов в проекте IList <Element> allElements = new FilteredElementCollector(_doc).WhereElementIsNotElementType().ToElements(); if (_doc.IsWorkshared) { WorksetTable worksetTable = _doc.GetWorksetTable(); IList <Workset> worksets = new FilteredWorksetCollector(_doc).OfKind(WorksetKind.UserWorkset).ToWorksets(); List <List <Element> > allElsEls = new List <List <Element> >(worksets.Count); foreach (Workset ws in worksets) { allElsEls.Add(new List <Element>()); } foreach (Element element in allElements) { Workset workset = worksetTable.GetWorkset(element.WorksetId); // Get's the Workset Table of the document. Then return the workset from the input WorksetId if (element.Category != null && (element.Category.Id.IntegerValue != (int)BuiltInCategory.OST_Grids && element.Category.Id.IntegerValue != (int)BuiltInCategory.OST_Levels && element.Category.Id.IntegerValue != (int)BuiltInCategory.OST_PreviewLegendComponents)) { Parameter param = element.get_Parameter(BuiltInParameter.ELEM_PARTITION_PARAM); if (param != null && !param.IsReadOnly) { bool flag = false; int index = -1; foreach (Workset ws in worksets) { ++index; if (Equals(ws.Id, workset.Id)) { flag = true; break; } } if (flag) { if (index != -1) { allElsEls[index].Add(element); } } } } } var infoWorksetForm = new PRSPKT_Apps.ElementsOnWorkset.WorksetExplorerForm(allElsEls, _doc, ((IEnumerable <Workset>)worksets).ToArray()); if (DialogResult.OK == infoWorksetForm.ShowDialog()) { List <Element> selectedElements = infoWorksetForm.GetSelectedElements(); UIdoc.Selection.SetElementIds(selectedElements.Select(q => q.Id).ToList()); } } else { TaskDialog.Show("Ошибка", "Проект не переведён в режим совместной работы"); } }
public static ViewPlan CreateWorksetFloorPlan(Document doc, ItemInfo itemInfo, ViewFamilyType viewPlanFamilyType, Level planLevel, bool overwrite) { ViewPlan viewPlan = null; string viewName = planLevel.Name + " - " + itemInfo.ItemName; using (TransactionGroup tg = new TransactionGroup(doc)) { tg.Start("Create Floor Plan"); try { FilteredElementCollector collector = new FilteredElementCollector(doc); List <ViewPlan> viewPlans = collector.OfClass(typeof(ViewPlan)).ToElements().Cast <ViewPlan>().ToList(); var views = from view in viewPlans where view.Name == viewName select view; if (views.Count() > 0) { if (overwrite) { viewPlan = views.First(); } else { return(viewPlan); } } if (null == viewPlan) { using (Transaction trans = new Transaction(doc)) { trans.Start("Create Plan View"); try { viewPlan = ViewPlan.Create(doc, viewPlanFamilyType.Id, planLevel.Id); viewPlan.Name = viewName; trans.Commit(); } catch (Exception ex) { trans.RollBack(); MessageBox.Show("Failed to create plan view.\n" + ex.Message, "Create Plan View", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } } using (Transaction trans = new Transaction(doc)) { trans.Start("Set Visibility"); try { FilteredWorksetCollector worksetCollector = new FilteredWorksetCollector(doc); IList <Workset> worksetList = worksetCollector.ToWorksets(); var worksets = from workset in worksetList where workset.Kind == WorksetKind.UserWorkset select workset; foreach (Workset ws in worksets) { if (ws.Kind == WorksetKind.UserWorkset) { if (ws.Id.IntegerValue == itemInfo.ItemId) { viewPlan.SetWorksetVisibility(ws.Id, WorksetVisibility.Visible); } else { viewPlan.SetWorksetVisibility(ws.Id, WorksetVisibility.Hidden); } } } trans.Commit(); } catch (Exception ex) { trans.RollBack(); MessageBox.Show("Failed to set visibility.\n" + ex.Message, "Set Visibility", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } } catch (Exception ex) { tg.RollBack(); MessageBox.Show("Failed to create floor plans by worksets.\n" + ex.Message, "Create Floor Plans by Worksets", MessageBoxButtons.OK, MessageBoxIcon.Warning); } tg.Assimilate(); } return(viewPlan); }
public static View3D CreateWorkset3DView(Document doc, ItemInfo itemInfo, ViewFamilyType view3dFamilyType, bool overwrite) { View3D view3D = null; try { string viewName = "WS - 3D - " + itemInfo.ItemName; using (TransactionGroup tg = new TransactionGroup(doc)) { tg.Start("Create 3D View"); try { FilteredElementCollector collector = new FilteredElementCollector(doc); List <View3D> view3ds = collector.OfClass(typeof(View3D)).ToElements().Cast <View3D>().ToList(); var views = from view in view3ds where view.Name == viewName select view; if (views.Count() > 0) { if (overwrite) { view3D = views.First(); } else { return(view3D); } } if (null == view3D) { using (Transaction trans = new Transaction(doc)) { trans.Start("Create Isometric"); try { view3D = View3D.CreateIsometric(doc, view3dFamilyType.Id); view3D.Name = viewName; if (view3D.CanModifyViewDiscipline()) { view3D.Discipline = ViewDiscipline.Coordination; } trans.Commit(); } catch (Exception ex) { trans.RollBack(); MessageBox.Show("Failed to create Isometric.\n" + ex.Message, "Create Isometric", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } } using (Transaction trans = new Transaction(doc)) { trans.Start("Set Visibility"); try { FilteredWorksetCollector worksetCollector = new FilteredWorksetCollector(doc); IList <Workset> worksetList = worksetCollector.ToWorksets(); var worksets = from workset in worksetList where workset.Kind == WorksetKind.UserWorkset select workset; foreach (Workset ws in worksets) { if (ws.Kind == WorksetKind.UserWorkset) { if (ws.Id.IntegerValue == itemInfo.ItemId) { view3D.SetWorksetVisibility(ws.Id, WorksetVisibility.Visible); } else { view3D.SetWorksetVisibility(ws.Id, WorksetVisibility.Hidden); } } } trans.Commit(); } catch (Exception ex) { trans.RollBack(); MessageBox.Show("Failed to set visibility.\n" + ex.Message, "Set Visibility", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } using (Transaction trans = new Transaction(doc)) { trans.Start("Set SectionBox"); try { collector = new FilteredElementCollector(doc, view3D.Id); List <Element> elements = collector.ToElements().ToList(); if (elements.Count > 0) { BoundingBoxXYZ boundingBox = GetBoundingBox(elements); if (null != boundingBox) { view3D.SetSectionBox(boundingBox); } } trans.Commit(); } catch (Exception ex) { trans.RollBack(); MessageBox.Show("Failed to set sectionbox.\n" + ex.Message, "Set Sectionbox", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } } catch (Exception ex) { MessageBox.Show("Failed to create 3d views by worksets.\n" + ex.Message, "Create 3D Views by Worksets", MessageBoxButtons.OK, MessageBoxIcon.Warning); tg.RollBack(); } tg.Assimilate(); } } catch (Exception ex) { MessageBox.Show("Failed to create workset views.\n" + ex.Message, "Create Workset 3D View", MessageBoxButtons.OK, MessageBoxIcon.Warning); } return(view3D); }
public Result Execute( ExternalCommandData commandData, ref string message, ElementSet elements) { UIApplication uiapp = commandData.Application; Application app = uiapp.Application; int check = 0; int sheetsNumber = 0; int viewsNumber = 0; int schedulesNumber = 0; int furnitureElements = 0; using (var formOpen = new FormOpenFile()) { formOpen.ShowDialog(); string fileName = formOpen.filePath; ModelPath modelP = ModelPathUtils.ConvertUserVisiblePathToModelPath(fileName); if (formOpen.DialogResult == winForms.DialogResult.OK) { OpenOptions optionDetach = new OpenOptions(); optionDetach.DetachFromCentralOption = DetachFromCentralOption.DetachAndPreserveWorksets; optionDetach.Audit = true; openDoc = app.OpenDocumentFile(modelP, optionDetach); IEnumerable <ViewFamilyType> viewFamilyTypes = from elem in new FilteredElementCollector(openDoc).OfClass(typeof(ViewFamilyType)) let type = elem as ViewFamilyType where type.ViewFamily == ViewFamily.ThreeDimensional select type; IEnumerable <ElementId> sheetIds = from elem in new FilteredElementCollector(openDoc).OfCategory(BuiltInCategory.OST_Sheets) select elem.Id; IEnumerable <ElementId> viewsIds = from elem in new FilteredElementCollector(openDoc).OfCategory(BuiltInCategory.OST_Views) where elem.Name != "Clarity_IFC _3D" select elem.Id; #if REVIT2019 IEnumerable <ElementId> schedulesIds = from elem in new FilteredElementCollector(openDoc).OfCategory(BuiltInCategory.OST_Schedules) select elem.Id; #elif REVIT2017 #endif List <BuiltInCategory> builtInCats = new List <BuiltInCategory>(); builtInCats.Add(BuiltInCategory.OST_Furniture); builtInCats.Add(BuiltInCategory.OST_Casework); builtInCats.Add(BuiltInCategory.OST_Planting); builtInCats.Add(BuiltInCategory.OST_Entourage); builtInCats.Add(BuiltInCategory.OST_Railings); builtInCats.Add(BuiltInCategory.OST_StairsRailing); ElementMulticategoryFilter filter1 = new ElementMulticategoryFilter(builtInCats); View3D view3d = null; using (Transaction tran = new Transaction(openDoc)) { tran.Start("Clarity Setup"); FilteredWorksetCollector worksetCollector = new FilteredWorksetCollector(openDoc).OfKind(WorksetKind.UserWorkset); try { view3d = View3D.CreateIsometric(openDoc, viewFamilyTypes.First().Id); view3d.Name = "Clarity_IFC _3D"; //uiapp.ActiveUIDocument.ActiveView = view3d; foreach (Workset e in worksetCollector) { view3d.SetWorksetVisibility(e.Id, WorksetVisibility.Visible); } } catch (Exception ex) { TaskDialog.Show("Error", "Name already taken" + "\n" + ex.Message); } try { sheetsNumber += sheetIds.Count(); if (sheetIds.Count() > 0) { openDoc.Delete(sheetIds.ToList()); } } catch (Exception ex) { TaskDialog.Show("Sheets Error", ex.Message); } try { viewsNumber += viewsIds.Count(); if (viewsIds.Count() > 0) { openDoc.Delete(viewsIds.ToList()); } } catch (Exception ex) { TaskDialog.Show("Views Error", ex.Message); } #if REVIT2019 try { if (schedulesIds.Count() > 0) { openDoc.Delete(schedulesIds.ToList()); schedulesNumber += schedulesIds.Count(); } } catch (Exception ex) { TaskDialog.Show("Schedule Error", ex.Message); } #elif REVIT2017 #endif if (formOpen.cleanArchModel) { int furnitureError = 0; ICollection <ElementId> toDelete = new FilteredElementCollector(openDoc).WherePasses(filter1).ToElementIds(); if (toDelete.Count() > 0) { string lastEx = ""; foreach (ElementId id in toDelete) { try { openDoc.Delete(id); furnitureElements += 1; } catch (Exception ex) { lastEx = $"{ex.Message}\n"; } } //Debug.WriteLine(lastEx.Message); TaskDialog.Show("Error", $"{furnitureElements} elements deleted. {furnitureError} cannot be deleted. Errors:\n{lastEx}"); } } if (formOpen.purgeModel) { ICollection <ElementId> purgeableElements = null; PurgeTool.GetPurgeableElements(openDoc, ref purgeableElements); try { while (purgeableElements.Count > 0) { //TaskDialog.Show("Purge Count", purgeableElements.Count().ToString()); PurgeTool.GetPurgeableElements(openDoc, ref purgeableElements); openDoc.Delete(purgeableElements); } } catch (Exception ex) { TaskDialog.Show("Purge Error", ex.Message); } } tran.Commit(); } SaveAsOptions saveOpt = new SaveAsOptions(); WorksharingSaveAsOptions wos = new WorksharingSaveAsOptions(); wos.SaveAsCentral = true; saveOpt.Compact = true; saveOpt.SetWorksharingOptions(wos); saveOpt.OverwriteExistingFile = true; openDoc.SaveAs(modelP, saveOpt); check += 1; } else { TaskDialog.Show("Result", "Command aborted."); } if (check > 0) { ICollection <ElementId> viewsId = new FilteredElementCollector(openDoc).OfCategory(BuiltInCategory.OST_Views).ToElementIds(); string viewsNames = ""; foreach (ElementId eid in viewsId) { viewsNames += openDoc.GetElement(eid).Name + Environment.NewLine; } TaskDialog.Show("Result", String.Format("Sheets deleted {0} \nViews deleted {1} \nSchedules deleted {2} \nViews in the model {3}", sheetsNumber, viewsNumber, furnitureElements, viewsNames)); } //PurgeMaterials(openDoc); too slooooooow }//close using return(Result.Succeeded); }
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements) { Document doc = commandData.Application.ActiveUIDocument.Document; if (!doc.IsWorkshared) { message = "Файл не является файлом совместной работы"; return(Result.Failed);; } //считываю список рабочих наборов string dllPath = System.Reflection.Assembly.GetExecutingAssembly().Location; string folder = System.IO.Path.GetDirectoryName(dllPath); System.Windows.Forms.OpenFileDialog dialog = new System.Windows.Forms.OpenFileDialog(); dialog.InitialDirectory = folder; dialog.Multiselect = false; dialog.Filter = "xml files (*.xml)|*.xml|All files (*.*)|*.*"; if (dialog.ShowDialog() != System.Windows.Forms.DialogResult.OK) { return(Result.Cancelled); } string xmlFilePath = dialog.FileName; InfosStorage storage = new InfosStorage(); System.Xml.Serialization.XmlSerializer serializer = new System.Xml.Serialization.XmlSerializer(typeof(InfosStorage)); using (StreamReader r = new StreamReader(xmlFilePath)) { storage = (InfosStorage)serializer.Deserialize(r); } if (storage.LinkedFilesPrefix == null) { storage.LinkedFilesPrefix = "#"; } using (Transaction t = new Transaction(doc)) { t.Start("Создание рабочих наборов"); //назначаю рабочие наборы в случае, если указана категория foreach (WorksetByCategory wb in storage.worksetsByCategory) { Workset wset = wb.GetWorkset(doc); List <BuiltInCategory> cats = wb.revitCategories; if (cats == null) { continue; } if (cats.Count == 0) { continue; } foreach (BuiltInCategory bic in cats) { List <Element> elems = new FilteredElementCollector(doc) .OfCategory(bic) .WhereElementIsNotElementType() .ToElements() .ToList(); foreach (Element elem in elems) { WorksetBy.SetWorkset(elem, wset); } } } //назначаю рабочие наборы по именам семейств List <FamilyInstance> famIns = new FilteredElementCollector(doc) .WhereElementIsNotElementType() .OfClass(typeof(FamilyInstance)) .Cast <FamilyInstance>() .ToList(); foreach (WorksetByFamily wb in storage.worksetsByFamily) { Workset wset = wb.GetWorkset(doc); List <string> families = wb.FamilyNames; if (families == null) { continue; } if (families.Count == 0) { continue; } foreach (string familyName in families) { List <FamilyInstance> curFamIns = famIns .Where(f => f.Symbol.FamilyName.StartsWith(familyName)) .ToList(); foreach (FamilyInstance fi in curFamIns) { WorksetBy.SetWorkset(fi, wset); } } } //назначаю рабочие наборы по именам типов List <Element> allElems = new FilteredElementCollector(doc) .WhereElementIsNotElementType() .Cast <Element>() .ToList(); foreach (WorksetByType wb in storage.worksetsByType) { Workset wset = wb.GetWorkset(doc); List <string> typeNames = wb.TypeNames; if (typeNames == null) { continue; } if (typeNames.Count == 0) { continue; } foreach (string typeName in typeNames) { foreach (Element elem in allElems) { ElementId typeId = elem.GetTypeId(); if (typeId == null || typeId == ElementId.InvalidElementId) { continue; } ElementType elemType = doc.GetElement(typeId) as ElementType; if (elemType == null) { continue; } if (elemType.Name.StartsWith(typeName)) { WorksetBy.SetWorkset(elem, wset); } } } } //назначаю рабочие наборы по значению параметров foreach (WorksetByParameter wb in storage.worksetsByParameter) { Workset wset = wb.GetWorkset(doc); string paramName = wb.ParameterName; string paramValue = wb.ParameterValue; List <Element> elemsFilterByParam = allElems .Where(e => e.LookupParameter(paramName).AsString().Equals(paramValue)).ToList(); foreach (Element elem in elemsFilterByParam) { WorksetBy.SetWorkset(elem, wset); } } //назначаю рабочие наборы для связанных файлов List <RevitLinkInstance> links = new FilteredElementCollector(doc) .OfClass(typeof(RevitLinkInstance)) .Cast <RevitLinkInstance>() .ToList(); foreach (RevitLinkInstance rli in links) { RevitLinkType linkFileType = doc.GetElement(rli.GetTypeId()) as RevitLinkType; if (linkFileType == null) { continue; } if (linkFileType.IsNestedLink) { continue; } string linkWorksetName1 = rli.Name.Split(':')[0]; string linkWorksetName2 = linkWorksetName1.Substring(0, linkWorksetName1.Length - 5); string linkWorksetName = storage.LinkedFilesPrefix + linkWorksetName2; bool checkExists = WorksetTable.IsWorksetNameUnique(doc, linkWorksetName); if (!checkExists) { continue; } Workset.Create(doc, linkWorksetName); Workset linkWorkset = new FilteredWorksetCollector(doc) .OfKind(WorksetKind.UserWorkset) .ToWorksets() .Where(w => w.Name == linkWorksetName) .First(); WorksetBy.SetWorkset(rli, linkWorkset); WorksetBy.SetWorkset(linkFileType, linkWorkset); } t.Commit(); } List <string> emptyWorksetsNames = WorksetTool.GetEmptyWorksets(doc); if (emptyWorksetsNames.Count > 0) { string msg = "Обнаружены пустые рабочие наборы! Их можно удалить вручную:\n"; foreach (string s in emptyWorksetsNames) { msg += s + "\n"; } TaskDialog.Show("Отчёт", msg); } return(Result.Succeeded); }
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements) { UIDocument uidoc = commandData.Application.ActiveUIDocument; Document doc = uidoc.Document; View activeview = uidoc.ActiveView; FilteredWorksetCollector collector = new FilteredWorksetCollector(doc); collector.OfKind(WorksetKind.UserWorkset); List <Workset> list_visible = new List <Workset>(); List <Workset> list_invisible = new List <Workset>(); foreach (Workset ws in collector) { if (activeview.IsWorksetVisible(ws.Id)) { list_visible.Add(ws); } else { list_invisible.Add(ws); } } //window Window1 window = new Window1(); window.listbox_visible.ItemsSource = list_visible; window.listbox_invisible.ItemsSource = list_invisible; //selected List <Workset> seleted_visible = new List <Workset>(); List <Workset> seleted_invisible = new List <Workset>(); if (window.ShowDialog() == true) { var objs1 = window.listbox_visible.SelectedItems; foreach (Object obj in objs1) { seleted_visible.Add(obj as Workset); } var objs2 = window.listbox_invisible.SelectedItems; foreach (Object obj in objs2) { seleted_invisible.Add(obj as Workset); } } //change visible using (Transaction transaction = new Transaction(doc)) { transaction.Start("改变工作集可见性"); foreach (Workset ws in seleted_visible) { activeview.SetWorksetVisibility(ws.Id, WorksetVisibility.Hidden); } foreach (Workset ws in seleted_invisible) { activeview.SetWorksetVisibility(ws.Id, WorksetVisibility.Visible); } transaction.Commit(); } return(Result.Succeeded); }
/// <summary> /// Collects model metrics and returns a dictionary /// </summary> /// <param name="doc">The active document</param> /// <returns>Dictionary</returns> public Dictionary <string, object> CollectModelData(Document doc, Application app) { /* * the basic strategy is to use filtered element collectors to collect the relevant data. * some helper functions are defined in order to collect more complicated metrics that require the use of several element collectors. * examples: unused elements and redundant elements require helper functions */ IList <FailureMessage> warnings = doc.GetWarnings(); IList <Element> linkedRVT = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_RvtLinks).WhereElementIsNotElementType().ToList(); Dictionary <string, IList <Element> > nonRvtLinks = RevitMethods.NonRVTLinkCollector(doc); IList <Element> linkedCAD = nonRvtLinks[RevitConstants.Strings.linkedCAD]; IList <Element> importedCAD = nonRvtLinks[RevitConstants.Strings.importedCAD]; IList <Element> importedSKP = nonRvtLinks[RevitConstants.Strings.importedSKP]; IList <Element> raster = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_RasterImages).WhereElementIsNotElementType().ToList(); IList <Element> sheets = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Sheets).WhereElementIsNotElementType().ToList(); IList <View> views = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Views).Cast <View>().Where(v => !v.IsTemplate).ToList(); IList <View> unplacedViews = RevitMethods.UnplacedViewCollector(doc, sheets); IList <Element> modelGroups = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_IOSModelGroups).WhereElementIsNotElementType().ToList(); IList <Element> detailGroups = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_IOSDetailGroups).WhereElementIsNotElementType().ToList(); IList <Family> inPlaceFamilies = new FilteredElementCollector(doc).OfClass(typeof(Family)).Cast <Family>().Where(f => f.IsInPlace).ToList(); IList <Element> designOptionElements = new FilteredElementCollector(doc).WhereElementIsNotElementType().Where(e => e.DesignOption != null).ToList(); IList <Workset> worksets = new FilteredWorksetCollector(doc).OfKind(WorksetKind.UserWorkset).ToList(); IList <Element> rooms = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Rooms).WhereElementIsNotElementType().ToList(); IList <SpatialElement> unplacedRooms = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Rooms).WhereElementIsNotElementType().Cast <SpatialElement>().Where(r => r.Area == 0 && r.Location == null).ToList(); IList <SpatialElement> redundantRooms = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Rooms).WhereElementIsNotElementType().Cast <SpatialElement>().Where(r => r.Area == 0 && r.Location != null).ToList(); IList <Element> redundantElements = RevitMethods.RedundantElementsCollector(warnings, doc); int unusedElements = unplacedViews.Count + unplacedRooms.Count + RevitMethods.UnusedFamiliesCollector(doc).Count; // collect model specific information (string writeDate, string writeTime) = UtilityMethods.FormatDateTime(); (string modelPath, string modelName, string modelSize) = RevitMethods.GetModelInfo(doc); string versionBuild = app.VersionBuild; // save collected data in a dictionary Dictionary <string, object> modelMetrics = new Dictionary <string, object>() { { "Model Name", modelName }, { "Model Path", modelPath }, { "Model Size", modelSize }, { "Warnings", warnings }, { "Linked RVT Files", linkedRVT }, { "Linked CAD Files", linkedCAD }, { "Imported CAD Files", importedCAD }, { "Imported SKP Files", importedSKP }, { "Raster Images", raster }, { "Sheets", sheets }, { "Views", views }, { "Unplaced Views", unplacedViews }, { "Model Groups", modelGroups }, { "Detail Groups", detailGroups }, { "In-place Families", inPlaceFamilies }, { "Elements in Design Options", designOptionElements }, { "Worksets", worksets }, { "Rooms", rooms }, { "Unplaced Rooms", unplacedRooms }, { "Redundant and Unenclosed Rooms", redundantRooms }, { "Redundant Elements", redundantElements }, { "Unused Elements", unusedElements }, { "Write Date", writeDate }, { "Write Time", writeTime }, { "Version Build", versionBuild }, }; return(modelMetrics); }
public SetupCWSRequest(UIApplication uiApp, String text) { MainUI uiForm = BARevitTools.Application.thisApp.newMainUi; RVTDocument doc = uiApp.ActiveUIDocument.Document; //Make the transaction options TransactWithCentralOptions TWCOptions = new TransactWithCentralOptions(); //Make the relinquish options RelinquishOptions relinquishOptions = new RelinquishOptions(true); //Make the synchronization options SynchronizeWithCentralOptions SWCOptions = new SynchronizeWithCentralOptions(); SWCOptions.Compact = true; SWCOptions.SetRelinquishOptions(relinquishOptions); //Make the worksharing SaveAs options WorksharingSaveAsOptions worksharingSaveOptions = new WorksharingSaveAsOptions(); worksharingSaveOptions.SaveAsCentral = true; worksharingSaveOptions.OpenWorksetsDefault = SimpleWorksetConfiguration.AllWorksets; //Make the save options SaveOptions projectSaveOptions = new SaveOptions(); projectSaveOptions.Compact = true; //Finally, make the SaveAs options SaveAsOptions projectSaveAsOptions = new SaveAsOptions(); projectSaveAsOptions.Compact = true; projectSaveAsOptions.OverwriteExistingFile = true; projectSaveAsOptions.SetWorksharingOptions(worksharingSaveOptions); //The worksetsToAdd list will the names of the worksets to create List <string> worksetsToAdd = new List <string>(); //Collect the names of the worksets from the defaults foreach (string item in uiForm.setupCWSDefaultListBox.Items) { worksetsToAdd.Add(item); } //Collect any names selected in the extended list foreach (string item in uiForm.setupCWSExtendedListBox.CheckedItems) { worksetsToAdd.Add(item); } //Collect the names of any user defined worksets foreach (DataGridViewRow row in uiForm.setupCWSUserDataGridView.Rows) { try { if (row.Cells[0].Value.ToString() != "") { worksetsToAdd.Add(row.Cells[0].Value.ToString()); } } catch { continue; } } //Collect all worksets in the current project List <Workset> worksets = new FilteredWorksetCollector(doc).Cast <Workset>().ToList(); List <string> worksetNames = new List <string>(); //Cycle through the worksets in the project if (worksets.Count > 0) { foreach (Workset workset in worksets) { //If Workset1 exists, rename it Arch if (workset.Name == "Workset1") { try { WorksetTable.RenameWorkset(doc, workset.Id, "Arch"); worksetNames.Add("Arch"); break; } catch { continue; } } else { worksetNames.Add(workset.Name); } } } //If the file has been saved and is workshared, continue if (doc.IsWorkshared && doc.PathName != "") { //Start a transaction Transaction t1 = new Transaction(doc, "CreateWorksets"); t1.Start(); //For each workset name in the list of worksets to add, continue foreach (string worksetName in worksetsToAdd) { //If the list of existing worksets does not contain the workset to make, continue if (!worksetNames.Contains(worksetName)) { //Create the new workset Workset.Create(doc, worksetName); } } t1.Commit(); try { //Save the project with the save options, then synchronize doc.Save(projectSaveOptions); doc.SynchronizeWithCentral(TWCOptions, SWCOptions); } catch { //Else, try using the SaveAs method, then synchronize doc.SaveAs(doc.PathName, projectSaveAsOptions); doc.SynchronizeWithCentral(TWCOptions, SWCOptions); } } //If the project has been saved and the document is not workshared, continue else if (!doc.IsWorkshared && doc.PathName != "") { //Make the document workshared and set the default worksets doc.EnableWorksharing("Shared Levels and Grids", "Arch"); //Add the default worksets to the list of pre-existing worksets worksetNames.Add("Shared Levels and Grids"); worksetNames.Add("Arch"); //Start the transaction Transaction t1 = new Transaction(doc, "MakeWorksets"); t1.Start(); foreach (string worksetName in worksetsToAdd) { //Create the workset if it does not exist in the list of pre-existing worksets if (!worksetNames.Contains(worksetName)) { Workset.Create(doc, worksetName); } } t1.Commit(); //Use the SaveAs method for saving the file, then synchronize doc.SaveAs(doc.PathName, projectSaveAsOptions); doc.SynchronizeWithCentral(TWCOptions, SWCOptions); } else { //If the project has not been saved, let the user know to save it first somewhere MessageBox.Show("Project file needs to be saved somewhere before it can be made a central model"); } }