private ElementParameterFilter EleParamGreaterFilter(
Document doc, string sParaName, double dValue)
{
SharedParameterElement para =
(from p in new FilteredElementCollector(doc)
.OfClass(typeof(SharedParameterElement))
.Cast <SharedParameterElement>()
where p.Name.Equals(sParaName)
select p).First();
ParameterValueProvider provider
= new ParameterValueProvider(para.Id);
FilterNumericRuleEvaluator evaluator
= new FilterNumericGreater();
double sLength_feet = UnitUtils.Convert(
dValue,
DisplayUnitType.DUT_METERS,
DisplayUnitType.DUT_DECIMAL_FEET);
double epsilon = 0.0001;
FilterRule rule = new FilterDoubleRule(
provider, evaluator, sLength_feet, epsilon);
ElementParameterFilter filter
= new ElementParameterFilter(rule);
return(filter);
}
private FilteredElementCollector GetFamilyInstanceByShareParamValue(
Document doc, BuiltInCategory bic, string sParaName, string sValue
)
{
SharedParameterElement para =
(from p in new FilteredElementCollector(doc)
.OfClass(typeof(SharedParameterElement))
.Cast <SharedParameterElement>()
where p.Name.Equals(sParaName)
select p).First();
ParameterValueProvider provider
= new ParameterValueProvider(para.Id);
FilterStringRuleEvaluator evaluator
= new FilterStringEquals();
string sType = sValue;
FilterRule rule = new FilterStringRule(
provider, evaluator, sType, false);
ElementParameterFilter filter
= new ElementParameterFilter(rule);
FilteredElementCollector collector
= new FilteredElementCollector(doc)
.OfCategory(bic)
.OfClass(typeof(FamilyInstance))
.WherePasses(filter);
return(collector);
}
public static IList <SharedParameter> GetSharedParameters(Document doc)
{
IList <SharedParameter> extSharedParams = new List <SharedParameter>();
BindingMap bindingMap = doc.ParameterBindings;
DefinitionBindingMapIterator it =
bindingMap.ForwardIterator();
it.Reset();
while (it.MoveNext())
{
InternalDefinition definition = it.Key as InternalDefinition;
Autodesk.Revit.DB.Binding currBinding = bindingMap.get_Item(definition);
// unearth the parameter's GUID
SharedParameterElement sharedParamElem =
doc.GetElement(definition.Id) as SharedParameterElement;
if (sharedParamElem == null)
{
continue;
}
SharedParameter sharedParam =
new SharedParameter(definition.Name, definition.ParameterType,
sharedParamElem.GuidValue, currBinding, definition.ParameterGroup);
extSharedParams.Add(sharedParam);
}
return(extSharedParams);
}
public static void ExportParameters(Document doc, string path)
{
DefinitionFile existingDefFile = doc.Application.OpenSharedParameterFile();
//
doc.Application.SharedParametersFilename = path;
DefinitionFile tempDefFile = doc.Application.OpenSharedParameterFile();
// Manager the Exported group
DefinitionGroup exported = null;
var query = from dg in tempDefFile.Groups
where dg.Name.Equals(doc.PathName + "-Exported")
select dg;
if (query.Count() == 0)
{
exported = tempDefFile.Groups.Create(doc.PathName + "-Exported");
}
else
{
exported = query.First();
}
// Iterate over the shared parameters in the document
BindingMap bindingMap = doc.ParameterBindings;
DefinitionBindingMapIterator it =
bindingMap.ForwardIterator();
it.Reset();
while (it.MoveNext())
{
InternalDefinition definition = it.Key as InternalDefinition;
Autodesk.Revit.DB.Binding currBinding = bindingMap.get_Item(definition);
// Corroborate that the current parameter has not been exported previously
Definition existingDef = exported.Definitions
.Where(d => (d.Name.Equals(definition.Name))).FirstOrDefault();
if (existingDef != null)
{
continue;
}
// unearth and assign the parameter's GUID
SharedParameterElement sharedParamElem =
doc.GetElement(definition.Id) as SharedParameterElement;
if (sharedParamElem == null)
{
continue;
}
ExternalDefinitionCreationOptions options =
new ExternalDefinitionCreationOptions(definition.Name, definition.ParameterType);
options.GUID = sharedParamElem.GuidValue;
Definition createdDefinition = exported.Definitions.Create(options);
}
}
/// <summary>
/// Helper method to control `SetAllowVaryBetweenGroups`
/// option for instance binding param
/// </summary>
static void SetInstanceParamVaryBetweenGroupsBehaviour(
Document doc,
Guid guid,
bool allowVaryBetweenGroups = true)
{
try // last resort
{
SharedParameterElement sp
= SharedParameterElement.Lookup(doc, guid);
// Should never happen as we will call
// this only for *existing* shared param.
if (null == sp)
{
return;
}
InternalDefinition def = sp.GetDefinition();
if (def.VariesAcrossGroups != allowVaryBetweenGroups)
{
// Must be within an outer transaction!
def.SetAllowVaryBetweenGroups(doc, allowVaryBetweenGroups);
}
}
catch { } // ideally, should report something to log...
}
public MyParameterDefinition(SharedParameterElement Spe)
{
spe = Spe;
id = Spe.Id.IntegerValue;
paramName = spe.Name;
guid = spe.GuidValue.ToString();
}
//private void CreateExternalSharedParamFile(string sharedParameterFile)
//{
// System.IO.FileStream fileStream = System.IO.File.Create(sharedParameterFile);
// fileStream.Close();
//}
//private void ShowDefinitionFileInfo(DefinitionFile myDefinitionFile)
//{
// StringBuilder fileInformation = new StringBuilder(500);
// // get the file name
// fileInformation.AppendLine("File Name: " + myDefinitionFile.Filename);
// // iterate the Definition groups of this file
// foreach (DefinitionGroup myGroup in myDefinitionFile.Groups)
// {
// // get the group name
// fileInformation.AppendLine("Group Name: " + myGroup.Name);
// // iterate the difinitions
// foreach (Definition definition in myGroup.Definitions)
// {
// // get definition name
// fileInformation.AppendLine("Definition Name: " + definition.Name);
// }
// }
// TaskDialog.Show("Revit", fileInformation.ToString());
//}
//private DefinitionFile SetAndOpenExternalSharedParamFile(Autodesk.Revit.ApplicationServices.Application application, string sharedParameterFile)
//{
// // set the path of shared parameter file to current Revit
// application.SharedParametersFilename = sharedParameterFile;
// // open the file
// return application.OpenSharedParameterFile();
//}
//private void ReadEditExternalParam(DefinitionFile file)
//{
// // get ExternalDefinition from shared parameter file
// DefinitionGroups myGroups = file.Groups;
// DefinitionGroup myGroup = myGroups.get_Item("MyGroup");
// if (myGroup != null)
// {
// ExternalDefinition myExtDef = myGroup.Definitions.get_Item("MyParam") as ExternalDefinition;
// if (myExtDef != null)
// {
// DefinitionGroup newGroup = myGroups.get_Item("AnotherGroup");
// if (newGroup != null)
// {
// // change the OwnerGroup of the ExternalDefinition
// myExtDef.OwnerGroup = newGroup;
// }
// }
// }
//}
private void createCategory()
{
try
{
SharedParameterElement sp = SharedParameterElement.Lookup(doc, new Guid("2FB57A90-CF7B-4F49-8127-B0C7F7276FD7"));
if (sp == null)
{
using (Transaction myTrans = new Transaction(doc))
{
myTrans.Start("Attach Parameters");
try
{
sharedParameterYarat(revitApp, "Parametre1", "REVITeRA", ParameterType.Text, true, new Guid("2FB57A90-CF7B-4F49-8127-B0C7F7276FD7"));
sharedParameterYarat(revitApp, "Parametre2", "REVITeRA", ParameterType.Text, true, new Guid("641644D9-B65F-4EF7-96A5-D9B243B8477D"));
sharedParameterYarat(revitApp, "Parametre3", "REVITeRA", ParameterType.Text, true, new Guid("208BB516-A3CB-47AC-B339-3EFDDF5DE71A"));
CategorySet cats1 = new CategorySet();
cats1 = revitApp.Create.NewCategorySet();
cats1.Insert(doc.Settings.Categories.get_Item(BuiltInCategory.OST_Walls));
sharedParameterEkle(revitApp, "Parametre1", cats1, BuiltInParameterGroup.INVALID, true);
sharedParameterEkle(revitApp, "Parametre2", cats1, BuiltInParameterGroup.INVALID, true);
sharedParameterEkle(revitApp, "Parametre3", cats1, BuiltInParameterGroup.INVALID, true);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
myTrans.Commit();
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
Parameter GetScheduleFieldParameter(ScheduleField scheduleField, Element elem)
{
Parameter parameter = null;
switch (scheduleField.FieldType)
{
case ScheduleFieldType.Instance:
// If the parameter is not a shared parameter,
// then it is an instance parameter
if (scheduleField.ParameterId == null)
{
parameter =
elem.LookupParameter(scheduleField.GetName());
}
// Conversely, it is a shared parameter
else
{
Document doc = elem.Document;
SharedParameterElement sharedParam =
doc.GetElement(scheduleField.ParameterId)
as SharedParameterElement;
// All shared parameteres use this type,
// be they instance or type parameters
// Try retrieving the parameter from an instance
parameter = elem.LookupParameter(sharedParam.Name);
// If the parameter is not present,
// then resort to a family type
if (parameter == null)
{
parameter = ((FamilyInstance)elem)
.Symbol.LookupParameter(sharedParam.Name);
}
}
return(parameter);
case ScheduleFieldType.ElementType:
// A type parameter of the schedules elements
parameter = ((FamilyInstance)elem)
.Symbol.LookupParameter(scheduleField.GetName());
return(parameter);
default:
throw new NotImplementedException(
"Other filed types have not been implemented yet.");
}
}
bool IsInstance(SharedParameterElement sharedParameter)
{
Document doc = sharedParameter.Document;
BindingMap bindingMap = doc.ParameterBindings;
Binding binding = bindingMap.get_Item(sharedParameter.GetDefinition());
if (binding is InstanceBinding)
{
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Generic Parameter value filter. An attempt to write a generic method,
/// that returns an element filter consumed by FilteredElementCollector.
/// </summary>
/// <typeparam name="T1">Type of the parameter VALUE to filter by.</typeparam>
/// <typeparam name="T2">Type of the PARAMETER to filter.</typeparam>
/// <param name="value">Currently: string, bool.</param>
/// <param name="parameterId">Currently: Guid, BuiltInCategory.</param>
/// <returns>ElementParameterFilter consumed by FilteredElementCollector.</returns>
public static ElementParameterFilter ParameterValueGenericFilter <T1, T2>(Document doc, T1 value, T2 parameterId)
{
//Initialize ParameterValueProvider
ParameterValueProvider pvp = null;
switch (parameterId)
{
case BuiltInParameter bip:
pvp = new ParameterValueProvider(new ElementId((int)bip));
break;
case Guid guid:
SharedParameterElement spe = SharedParameterElement.Lookup(doc, guid);
pvp = new ParameterValueProvider(spe.Id);
break;
default:
throw new NotImplementedException("ParameterValueGenericFilter: T2 (parameter) type not implemented!");
}
//Branch off to value types
switch (value)
{
case string str:
FilterStringRuleEvaluator fsrE = new FilterStringEquals();
FilterStringRule fsr = new FilterStringRule(pvp, fsrE, str, false);
return(new ElementParameterFilter(fsr));
case bool bol:
int _value;
if (bol == true)
{
_value = 1;
}
else
{
_value = 0;
}
FilterNumericRuleEvaluator fnrE = new FilterNumericEquals();
FilterIntegerRule fir = new FilterIntegerRule(pvp, fnrE, _value);
return(new ElementParameterFilter(fir));
default:
throw new NotImplementedException("ParameterValueGenericFilter: T1 (value) type not implemented!");
}
}
public static bool TryGetElementBinding(this Document document, Guid guid, out InternalDefinition internalDefinition, out ElementBinding elementBinding)
{
internalDefinition = null;
elementBinding = null;
if (document == null || document.ParameterBindings == null)
{
return(false);
}
DefinitionBindingMapIterator definitionBindingMapIterator = document.ParameterBindings.ForwardIterator();
if (definitionBindingMapIterator == null)
{
return(false);
}
while (definitionBindingMapIterator.MoveNext())
{
InternalDefinition internalDefinition_Temp = definitionBindingMapIterator.Key as InternalDefinition;
if (internalDefinition_Temp == null)
{
continue;
}
ElementId elementId = internalDefinition_Temp.Id;
if (elementId == null || elementId == Autodesk.Revit.DB.ElementId.InvalidElementId)
{
continue;
}
SharedParameterElement sharedParameterElement = document.GetElement(elementId) as SharedParameterElement;
if (sharedParameterElement == null)
{
continue;
}
if (guid == sharedParameterElement.GuidValue)
{
elementBinding = (ElementBinding)definitionBindingMapIterator.Current;
internalDefinition = internalDefinition_Temp;
return(true);
}
}
return(false);
}
/// <summary>
/// The SerializeSharedParameters
/// </summary>
/// <param name="e">The e<see cref="Element"/></param>
/// <returns>The <see cref="string"/></returns>
public static string SerializeSharedParameters(Element e, Document doc)
{
string parameters = "";
IList <Parameter> paraList = e.GetOrderedParameters();
foreach (Parameter para in e.GetOrderedParameters())
{
if (para.IsShared == true)
{
SharedParameterElement sharedParameter = doc.GetElement(para.Id) as SharedParameterElement;
if (sharedParameter.GetDefinition().Visible == true)
{
parameters += string.Format("{0}:{1}={2}", para.Id, para.Definition.Name, ParameterToString(para)) + ";";
}
}
}
return(parameters);
}
void ReconstructSharedParameterByName
(
Document doc,
ref SharedParameterElement element,
[Description("Parameter Name")] string name,
[Description("Overwrite Parameter definition if found"), Optional, DefaultValue(false)] bool overwrite
)
{
var parameterGUID = default(Guid?);
var parameterType = ParameterType.Text;
var parameterGroup = BuiltInParameterGroup.PG_DATA;
bool instance = true;
bool visible = true;
using (var bindings = doc.ParameterBindings.ReverseIterator())
{
while (bindings.MoveNext())
{
if (bindings.Key is InternalDefinition def)
{
if
(
def.Name == name &&
def.Visible == visible &&
def.ParameterType == parameterType &&
def.ParameterGroup == parameterGroup &&
(instance ? bindings.Current is InstanceBinding : bindings.Current is TypeBinding)
)
{
if (doc.GetElement(def.Id) is SharedParameterElement parameterElement)
{
if (!overwrite)
{
ReplaceElement(ref element, parameterElement);
throw new CancelException($"A parameter called \"{name}\" is already in the document");
}
parameterGUID = parameterElement.GuidValue;
}
}
}
}
}
using (var defOptions = new ExternalDefinitionCreationOptions(name, parameterType)
{
Visible = visible
})
{
if (parameterGUID.HasValue)
{
defOptions.GUID = parameterGUID.Value;
}
using (var definitionFile = Revit.ActiveUIApplication.Application.CreateSharedParameterFile())
{
if (definitionFile?.Groups.Create(LabelUtils.GetLabelFor(parameterGroup)).Definitions.Create(defOptions) is ExternalDefinition definition)
{
// TODO : Ask for categories
using (var categorySet = new CategorySet())
{
foreach (var category in doc.Settings.Categories.Cast <Category>().Where(category => category.AllowsBoundParameters))
{
categorySet.Insert(category);
}
var binding = instance ? (ElementBinding) new InstanceBinding(categorySet) : (ElementBinding) new TypeBinding(categorySet);
if (!doc.ParameterBindings.Insert(definition, binding, parameterGroup))
{
if (!overwrite || !doc.ParameterBindings.ReInsert(definition, binding, parameterGroup))
{
throw new InvalidOperationException("Failed while creating the parameter binding.");
}
}
}
parameterGUID = definition.GUID;
}
}
}
ReplaceElement(ref element, SharedParameterElement.Lookup(doc, parameterGUID.Value));
}
void ReconstructParameterByName
(
Document doc,
ref Autodesk.Revit.DB.Element element,
[Description("Parameter Name")] string name,
[Description("Overwrite Parameter definition if found"), Optional, DefaultValue(false)] bool overwrite
)
{
var app = Revit.ActiveUIApplication.Application;
var parameterType = ParameterType.Text;
var parameterGroup = BuiltInParameterGroup.PG_DATA;
bool instance = true;
bool visible = true;
if (!overwrite)
{
using (var bindings = doc.ParameterBindings.ReverseIterator())
{
while (bindings.MoveNext())
{
if (bindings.Key is InternalDefinition def)
{
if
(
def.Name == name &&
def.Visible == visible &&
def.ParameterType == parameterType &&
def.ParameterGroup == parameterGroup &&
bindings.Current is InstanceBinding)
{
if (doc.GetElement(def.Id) is ParameterElement parameterElement)
{
ReplaceElement(ref element, parameterElement);
throw new WarningException($"A parameter called \"{name}\" is already in the document");
}
}
}
}
}
}
using (var defOptions = new ExternalDefinitionCreationOptions(name, parameterType)
{
Visible = visible
})
{
string sharedParametersFilename = app.SharedParametersFilename;
string tempParametersFilename = Path.GetTempFileName() + ".txt";
ExternalDefinition definition = null;
try
{
// Create Temp Shared Parameters File
{
using (File.Create(tempParametersFilename)) { }
app.SharedParametersFilename = tempParametersFilename;
}
definition = app.OpenSharedParameterFile().Groups.Create(parameterGroup.ToString()).Definitions.Create(defOptions) as ExternalDefinition;
}
finally
{
// Restore User Shared Parameters File
app.SharedParametersFilename = sharedParametersFilename;
File.Delete(tempParametersFilename);
}
if (overwrite || !doc.ParameterBindings.Contains(definition))
{
// TODO : Ask for categories
var categorySet = new CategorySet();
foreach (var category in doc.Settings.Categories.Cast <Category>().Where(category => category.AllowsBoundParameters))
{
categorySet.Insert(category);
}
var binding = instance ? (ElementBinding) new InstanceBinding(categorySet) : (ElementBinding) new TypeBinding(categorySet);
if (!doc.ParameterBindings.Insert(definition, binding, parameterGroup))
{
throw new InvalidOperationException("Failed while creating the parameter binding.");
}
}
ReplaceElement(ref element, SharedParameterElement.Lookup(doc, definition.GUID));
}
}
public void ParseSchedule(ViewSchedule schedule, string filePath, string fileHash, bool isOnSheet)
{
if (!schedule.IsTitleblockRevisionSchedule && !schedule.IsTemplate && schedule.Definition.ShowHeaders)
{
var scheduleFieldIds = schedule.Definition.GetFieldOrder();
List <ScheduleLine> lines = new List <ScheduleLine>();
var indexCount = 0;
for (int i = 0; i < scheduleFieldIds.Count; i++)
{
var scheduleField = schedule.Definition.GetField(scheduleFieldIds[i]);
if (scheduleField.IsHidden)
{
continue;
}
var idString = string.Empty;
var isShared = false;
if (scheduleField.ParameterId.IntegerValue > 0)
{
var elem = schedule.Document.GetElement(scheduleField.ParameterId);
if (elem is SharedParameterElement)
{
SharedParameterElement shElem = elem as SharedParameterElement;
idString = shElem.GuidValue.ToString();
isShared = true;
}
}
var scheduleLine = new ScheduleLine()
{
Filepath = filePath,
Filename = Path.GetFileName(filePath),
Hash = fileHash,
ScheduleTitle = schedule.Name,
IsOnSheet = isOnSheet,
OriginalColumnHeader = scheduleField.ColumnHeading.Trim(),
ParameterName = scheduleField.GetName().Trim(),
SharedParameterGuid = idString,
FieldType = scheduleField.FieldType,
IsShared = isShared,
ColumnIndex = indexCount
};
lines.Add(scheduleLine);
indexCount++;
}
var sectionData = schedule.GetTableData().GetSectionData(SectionType.Body);
List <int> mergedRowIndicesAcrossColumns = new List <int>();
bool hasGrandTotal = schedule.Definition.ShowGrandTotal;
if (hasGrandTotal)
{
mergedRowIndicesAcrossColumns.Add(sectionData.LastRowNumber);
}
for (int col = sectionData.FirstColumnNumber; col <= sectionData.LastColumnNumber; col++)
{
var columnHeaders = string.Empty;
var columnValues = string.Empty;
var matchingLine = lines.FirstOrDefault(x => x.ColumnIndex == col);
if (matchingLine != null)
{
bool isMatchingOriginalText = false;
TableMergedCell previousMergedData = null;
var previousMergedCellTopRowNumber = sectionData.LastRowNumber;
var previousMergedCellLeftRowNumber = sectionData.FirstColumnNumber;
//Read each cell of the column in reverse order to build up values and headers
for (int row = sectionData.LastRowNumber; row >= sectionData.FirstRowNumber; row--)
{
var cellText = schedule.GetCellText(SectionType.Body, row, col);
var mergedData = sectionData.GetMergedCell(row, col);
var mergedTopLeftCellText = sectionData.GetCellText(mergedData.Top, mergedData.Left).Trim();
var mergedBottomLeftCellText = sectionData.GetCellText(mergedData.Bottom, mergedData.Left).Trim();
bool isMergedAcrossRowsInColumn = false;
bool isRowMergedAcrossAllColumns = false;
if (row != sectionData.LastRowNumber)
{
isMergedAcrossRowsInColumn = IsMergedInColumnOnly(mergedData, previousMergedData);
}
if (mergedData.Top == mergedData.Bottom &&
mergedData.Left == sectionData.FirstColumnNumber &&
mergedData.Right == sectionData.LastColumnNumber)
{
isRowMergedAcrossAllColumns = true;
mergedRowIndicesAcrossColumns.Add(row);
}
if (!isMatchingOriginalText)
{
isMatchingOriginalText = (matchingLine.OriginalColumnHeader == mergedTopLeftCellText);
}
if (isMatchingOriginalText)
{
if (isMergedAcrossRowsInColumn)
{
//The merged column value has already been found from the previous cell's merged data; skip to next row
row = mergedData.Top;
}
else
{
columnHeaders = (!string.IsNullOrEmpty(columnHeaders))
? string.Format("{0}|{1}", mergedTopLeftCellText, columnHeaders)
: mergedTopLeftCellText;
}
}
else
{
if (row == sectionData.FirstRowNumber && string.IsNullOrEmpty(cellText))
{
continue;
}
else if (!isRowMergedAcrossAllColumns && !mergedRowIndicesAcrossColumns.Contains(row))
{
columnValues = (!string.IsNullOrEmpty(columnValues))
? string.Format("{0}|{1}", cellText, columnValues)
: cellText;
}
}
previousMergedCellTopRowNumber = mergedData.Top;
previousMergedCellLeftRowNumber = mergedData.Left;
previousMergedData = mergedData;
}
matchingLine.DelimitedColumnHeaders = columnHeaders;
matchingLine.ColumnValues = columnValues.TrimStart('|');
}
}
WriteCsv(lines);
lines.Clear();
}
}
//private UIDocument _uiDoc;
public Result CreateAllItemsSchedule(UIDocument uiDoc)
{
try
{
Document doc = uiDoc.Document;
FilteredElementCollector sharedParameters = new FilteredElementCollector(doc);
sharedParameters.OfClass(typeof(SharedParameterElement));
#region Debug
////Debug
//StringBuilder sbDev = new StringBuilder();
//var list = new ParameterDefinition().ElementParametersAll;
//int i = 0;
//foreach (SharedParameterElement sp in sharedParameters)
//{
// sbDev.Append(sp.GuidValue + "\n");
// sbDev.Append(list[i].Guid.ToString() + "\n");
// i++;
// if (i == list.Count) break;
//}
////sbDev.Append( + "\n");
//// Clear the output file
//File.WriteAllBytes(InputVars.OutputDirectoryFilePath + "\\Dev.pcf", new byte[0]);
//// Write to output file
//using (StreamWriter w = File.AppendText(InputVars.OutputDirectoryFilePath + "\\Dev.pcf"))
//{
// w.Write(sbDev);
// w.Close();
//}
#endregion
Transaction t = new Transaction(doc, "Create items schedules");
t.Start();
#region Schedule ALL elements
ViewSchedule schedAll = ViewSchedule.CreateSchedule(doc, ElementId.InvalidElementId,
ElementId.InvalidElementId);
schedAll.Name = "PCF - ALL Elements";
schedAll.Definition.IsItemized = false;
IList <SchedulableField> schFields = schedAll.Definition.GetSchedulableFields();
foreach (SchedulableField schField in schFields)
{
if (schField.GetName(doc) != "Family and Type")
{
continue;
}
ScheduleField field = schedAll.Definition.AddField(schField);
ScheduleSortGroupField sortGroupField = new ScheduleSortGroupField(field.FieldId);
schedAll.Definition.AddSortGroupField(sortGroupField);
}
string curUsage = "U";
string curDomain = "ELEM";
var query = from p in new plst().LPAll where p.Usage == curUsage && p.Domain == curDomain select p;
foreach (pdef pDef in query.ToList())
{
SharedParameterElement parameter = (from SharedParameterElement param in sharedParameters
where param.GuidValue.CompareTo(pDef.Guid) == 0
select param).First();
SchedulableField queryField = (from fld in schFields where fld.ParameterId.IntegerValue == parameter.Id.IntegerValue select fld).First();
ScheduleField field = schedAll.Definition.AddField(queryField);
if (pDef.Name != "PCF_ELEM_TYPE")
{
continue;
}
ScheduleFilter filter = new ScheduleFilter(field.FieldId, ScheduleFilterType.HasParameter);
schedAll.Definition.AddFilter(filter);
}
#endregion
#region Schedule FILTERED elements
ViewSchedule schedFilter = ViewSchedule.CreateSchedule(doc, ElementId.InvalidElementId,
ElementId.InvalidElementId);
schedFilter.Name = "PCF - Filtered Elements";
schedFilter.Definition.IsItemized = false;
schFields = schedFilter.Definition.GetSchedulableFields();
foreach (SchedulableField schField in schFields)
{
if (schField.GetName(doc) != "Family and Type")
{
continue;
}
ScheduleField field = schedFilter.Definition.AddField(schField);
ScheduleSortGroupField sortGroupField = new ScheduleSortGroupField(field.FieldId);
schedFilter.Definition.AddSortGroupField(sortGroupField);
}
foreach (pdef pDef in query.ToList())
{
SharedParameterElement parameter = (from SharedParameterElement param in sharedParameters
where param.GuidValue.CompareTo(pDef.Guid) == 0
select param).First();
SchedulableField queryField = (from fld in schFields where fld.ParameterId.IntegerValue == parameter.Id.IntegerValue select fld).First();
ScheduleField field = schedFilter.Definition.AddField(queryField);
if (pDef.Name != "PCF_ELEM_TYPE")
{
continue;
}
ScheduleFilter filter = new ScheduleFilter(field.FieldId, ScheduleFilterType.HasParameter);
schedFilter.Definition.AddFilter(filter);
filter = new ScheduleFilter(field.FieldId, ScheduleFilterType.NotEqual, "");
schedFilter.Definition.AddFilter(filter);
}
#endregion
#region Schedule Pipelines
ViewSchedule schedPipeline = ViewSchedule.CreateSchedule(doc, new ElementId(BuiltInCategory.OST_PipingSystem), ElementId.InvalidElementId);
schedPipeline.Name = "PCF - Pipelines";
schedPipeline.Definition.IsItemized = false;
schFields = schedPipeline.Definition.GetSchedulableFields();
foreach (SchedulableField schField in schFields)
{
if (schField.GetName(doc) != "Family and Type")
{
continue;
}
ScheduleField field = schedPipeline.Definition.AddField(schField);
ScheduleSortGroupField sortGroupField = new ScheduleSortGroupField(field.FieldId);
schedPipeline.Definition.AddSortGroupField(sortGroupField);
}
curDomain = "PIPL";
foreach (pdef pDef in query.ToList())
{
SharedParameterElement parameter = (from SharedParameterElement param in sharedParameters
where param.GuidValue.CompareTo(pDef.Guid) == 0
select param).First();
SchedulableField queryField = (from fld in schFields where fld.ParameterId.IntegerValue == parameter.Id.IntegerValue select fld).First();
schedPipeline.Definition.AddField(queryField);
}
#endregion
t.Commit();
sharedParameters.Dispose();
return(Result.Succeeded);
}
catch (Exception e)
{
BuildingCoderUtilities.InfoMsg(e.Message);
return(Result.Failed);
}
}
/// <summary>
/// Проверяет налиxие общего параметра у элемента. Если параметр есть - возвращает его. Иначе добавляет параметр из файла общих параметров.
/// </summary>
/// <param name="elem"></param>
/// <param name="app"></param>
/// <param name="catset"></param>
/// <param name="ParameterName"></param>
/// <param name="paramGroup"></param>
/// <param name="SetVaryByGroups"></param>
/// <returns></returns>
public static Parameter CheckAndAddSharedParameter(Element elem, Application app, CategorySet catset, string ParameterName, BuiltInParameterGroup paramGroup, bool SetVaryByGroups)
{
Document doc = elem.Document;
Parameter param = elem.LookupParameter(ParameterName);
if (param != null)
{
return(param);
}
string oldSharedParamsFile = app.SharedParametersFilename;
app.SharedParametersFilename = @"\\picompany.ru\pikp\lib\_CadSettings\02_Revit\04. Shared Parameters\SP-ALL-PIC.txt";
ExternalDefinition exDef = null;
string sharedFile = app.SharedParametersFilename;
DefinitionFile sharedParamFile = app.OpenSharedParameterFile();
foreach (DefinitionGroup defgroup in sharedParamFile.Groups)
{
foreach (Definition def in defgroup.Definitions)
{
if (def.Name == ParameterName)
{
exDef = def as ExternalDefinition;
}
}
}
if (exDef == null)
{
throw new Exception("В файл общих параметров не найден общий параметр " + ParameterName);
}
bool checkContains = doc.ParameterBindings.Contains(exDef);
if (checkContains)
{
var res = BindSharedParam(doc, elem, ParameterName, exDef);
}
InstanceBinding newIB = app.Create.NewInstanceBinding(catset);
doc.ParameterBindings.Insert(exDef, newIB, paramGroup);
if (SetVaryByGroups)
{
doc.Regenerate();
SharedParameterElement spe = SharedParameterElement.Lookup(doc, exDef.GUID);
InternalDefinition intDef = spe.GetDefinition();
intDef.SetAllowVaryBetweenGroups(doc, true);
}
doc.Regenerate();
app.SharedParametersFilename = oldSharedParamsFile;
param = elem.LookupParameter(ParameterName);
if (param == null)
{
throw new Exception("Не удалось добавить обший параметр " + ParameterName);
}
return(param);
}
public SharedParameter(SharedParameterElement sharedParameterElement)
{
OriginSharedParameterElement = sharedParameterElement;
Name = sharedParameterElement.Name;
Guid = sharedParameterElement.GuidValue;
}
private void Stream( ArrayList data, SharedParameterElement sharedParamElem )
{
data.Add( new Snoop.Data.ClassSeparator( typeof( SharedParameterElement ) ) );
data.Add( new Snoop.Data.String( "GUID", sharedParamElem.GuidValue.ToString() ) );
}
Result IExternalCommand.Execute(ExternalCommandData commandData, ref string message, Autodesk.Revit.DB.ElementSet elements)
{
UIApplication uiapp = commandData.Application;
UIDocument uidoc = uiapp.ActiveUIDocument;
Application app = uiapp.Application;
Document doc = uidoc.Document;
ElementId idPhase = doc.Phases.get_Item(doc.Phases.Size - 1).Id;
//Фильтр по общему параметру "ADSK_Номер здания"
List <SharedParameterElement> shParamElements = new FilteredElementCollector(doc)
.OfClass(typeof(SharedParameterElement))
.Cast <SharedParameterElement>()
.ToList();
SharedParameterElement shParam = shParamElements.Where(x => x.Name == "ADSK_Номер здания").First();
//Фильтр помещений
FilterableValueProvider providerRoom = new ParameterValueProvider(new ElementId((int)BuiltInParameter.ROOM_PHASE_ID));
FilterNumericRuleEvaluator evaluator = new FilterNumericEquals();
FilterElementIdRule rRule = new FilterElementIdRule(providerRoom, evaluator, idPhase);
ElementParameterFilter room_filter = new ElementParameterFilter(rRule);
FilterableValueProvider provRoomSchool = new ParameterValueProvider(shParam.Id);
FilterStringRuleEvaluator StrEvaluator = new FilterStringEquals();
FilterRule rScRule = new FilterStringRule(provRoomSchool, StrEvaluator, "", false);
ElementParameterFilter roomSc_filter = new ElementParameterFilter(rScRule);
IList <Element> revit_rooms = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Rooms)
.WhereElementIsNotElementType()
.WherePasses(room_filter)
.WherePasses(roomSc_filter)
.ToElements();
//Фильтр стен
FilterableValueProvider provider = new ParameterValueProvider(new ElementId((int)BuiltInParameter.PHASE_CREATED));
FilterElementIdRule fRule = new FilterElementIdRule(provider, evaluator, idPhase);
ElementParameterFilter wall_filter = new ElementParameterFilter(fRule);
IList <Element> revit_walls = new FilteredElementCollector(doc).OfCategory(BuiltInCategory.OST_Walls)
.WhereElementIsNotElementType()
.WherePasses(wall_filter)
.ToElements();
//Перенос помещений и стен в объекты наших классов
List <GhostRoom> rooms = revit_rooms.Select(x => new GhostRoom(x)).ToList();
List <GhostWall> walls = new List <GhostWall>();
foreach (Element w in revit_walls)
{
if (w.getP("Помещение") != null & w.getP("Помещение") != "")
{
walls.Add(new GhostWall(w, null));
}
}
foreach (string i in rooms.Select(x => x.Floor).Distinct())
{
}
using (Transaction tr = new Transaction(doc, "Otdelka"))
{
tr.Start();
foreach (GhostRoom r in rooms)
{
r.Commit();
}
tr.Commit();
}
return(Result.Succeeded);
}
