Esempio n. 1
0
        public Result Execute(
            ExternalCommandData commandData,
            ref string message,
            ElementSet elements)
        {
            UIApplication uiapp = commandData.Application;
            UIDocument    uidoc = uiapp.ActiveUIDocument;
            Application   app   = uiapp.Application;



            using (var formOpen = new FormOpenFile())
            {
                formOpen.ShowDialog();

                string[] filePath = System.IO.Directory.GetFiles(formOpen.filePath);

                foreach (string file in filePath)
                {
                    Document open_file = app.OpenDocumentFile(file);


                    FamilyManager fm = open_file.FamilyManager;


                    using (Transaction t = new Transaction(open_file, "Remove types"))
                    {
                        t.Start();

                        FamilyTypeSet familyTypes = fm.Types;

                        int count = familyTypes.Size;

                        while (count > 1)
                        {
                            fm.DeleteCurrentType();
                            count -= 1;
                        }

                        try
                        {
                            fm.RenameCurrentType("Default");
                        }
                        catch
                        {
                            //Do nothing
                        }


                        ICollection <ElementId> purgeableElements = null;

                        if (PurgeTool.GetPurgeableElements(open_file, ref purgeableElements) & purgeableElements.Count > 0)
                        {
                            open_file.Delete(purgeableElements);
                        }


                        t.Commit();


                        /*
                         * Press.Keys("PU");
                         * winForm.SendKeys.SendWait("{ENTER}");
                         *
                         * String s_commandToDisable = "ID_PURGE_UNUSED";
                         * RevitCommandId s_commandId = RevitCommandId.LookupCommandId(s_commandToDisable);
                         * uiapp.PostCommand(s_commandId);*/
                    }

                    //open_file.Save();
                    open_file.Close();
                }
            }

            return(Result.Succeeded);
        }
Esempio n. 2
0
        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);
        }
Esempio n. 3
0
        public Result Execute(
            ExternalCommandData commandData,
            ref string message,
            ElementSet elements)
        {
            UIApplication uiapp = commandData.Application;
            Application   app   = uiapp.Application;

            int check = 0;

            Document openDoc = null;

            using (var formOpen = new FormOpenFile())
            {
                formOpen.ShowDialog();

                string fileName = formOpen.filePath;

                ModelPath modelP = ModelPathUtils.ConvertUserVisiblePathToModelPath(fileName);

                OpenOptions optionDetach = new OpenOptions();

                optionDetach.DetachFromCentralOption = DetachFromCentralOption.DetachAndPreserveWorksets;

                openDoc = app.OpenDocumentFile(modelP, optionDetach);

                check += 1;

                if (formOpen.DialogResult == winForms.DialogResult.OK)
                {
                    using (var form = new FormPickSheets())
                    {
                        List <ViewSheet> collector = Helpers.CollectViewSheet(openDoc);

                        foreach (ViewSheet vs in collector)
                        {
                            form.sheetNames.Add(vs.Name);
                            form.sheetNumbers.Add(vs.SheetNumber);
                        }

                        List <ViewSheetSet> allViewSheets = Helpers.CollectViewSheetSets(openDoc);

                        foreach (ViewSheetSet vs in allViewSheets)
                        {
                            form.dictSheetSetsNames.Add(vs.Name, Helpers.SheetInViewSheetsSets(vs));
                        }

                        Dictionary <string, PrintSetting> printSetting = Helpers.GetPrintersSettings(openDoc);

                        form.printSettings = printSetting.Keys.ToList();

                        form.ShowDialog();

                        if (form.DialogResult == winForms.DialogResult.Cancel)
                        {
                            return(Result.Cancelled);
                        }

                        string destination = @"C:\Temp\";

                        //TaskDialog.Show("result", Helpers.CollectViewSheet(openDoc));

                        List <ViewSheet> sheetList = Helpers.FindViewSheetByNumber(openDoc, form.pickedNumbers);

                        PrintSetting chosenPrintSet = printSetting.Values.ElementAt(form.pickedPrintSet);

                        foreach (ViewSheet sheet in sheetList)
                        {
                            try
                            {
                                ViewSet vs = Helpers.CreateViewset(openDoc, sheet.SheetNumber);//create a viewset with each view to be printed (only way to be able to set the file names)
                            }
                            catch
                            {
                                TaskDialog.Show("Error", "Can't create ViewSet");
                            }
                            Helpers.PrintDrawingsFromList(openDoc, sheet, destination + form.prefix + sheet.SheetNumber + Helpers.SheetRevision(sheet) + ".pdf", chosenPrintSet);
                        }

                        openDoc.Close(false);
                        check += -1;

                        if (check == 0)
                        {
                            TaskDialog.Show("Result", "The pdfs will appear in the printer default folder (something like C:\\Users\\[your name]\\Documents)");
                        }
                        else
                        {
                            TaskDialog.Show("Result", "Something went wrong");
                        }
                    }
                }
            }


            return(Result.Succeeded);
        }