public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
UIDocument uidoc = commandData.Application.ActiveUIDocument;
Document doc = uidoc.Document;
try
{
Reference pickedObj = uidoc.Selection.PickObject(Autodesk.Revit.UI.Selection.ObjectType.Element);
if (pickedObj != null)
{
ElementId elementId = pickedObj.ElementId;
Element element = doc.GetElement(elementId);
Parameter param = element.LookupParameter("Head Height");
InternalDefinition paramDef = param.Definition as InternalDefinition;
TaskDialog.Show("Parameters",
string.Format("{0} parameter of type {1} with builtinparameter {2}",
paramDef.Name, paramDef.UnitType, paramDef.BuiltInParameter));
}
return(Result.Succeeded);
}
catch (Exception e)
{
message = e.Message;
return(Result.Failed);
}
}
public static void WallElementMySQLPara(Document doc, FilteredElementCollector wallCollector, System.Data.DataTable dt)
{
foreach (Element ele in wallCollector)
{
Wall wall = ele as Wall;
Level level = doc.GetElement(wall.LevelId) as Level;
if (wall != null)
{
double height = 0.0;
foreach (Autodesk.Revit.DB.Parameter param in wall.Parameters)
{
InternalDefinition definition = param.Definition as InternalDefinition;
if (null == definition)
{
continue;
}
if (BuiltInParameter.WALL_USER_HEIGHT_PARAM == definition.BuiltInParameter)
{
height = param.AsDouble();
}
}
CreateWallMySQLRow(dt, wall.WallType.Name, level.Name, FeetTomm(wall.Width), FeetTomm(height));
}
}
}
/// <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 Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
UIDocument uidoc = commandData.Application.ActiveUIDocument;
Document doc = uidoc.Document;
try
{
Reference pickObj = uidoc.Selection.PickObject(ObjectType.Element);
if (pickObj != null)
{
var eleId = pickObj.ElementId;
var ele = doc.GetElement(eleId);
//Get parameter
Parameter param = ele.LookupParameter("Head Height");
InternalDefinition paramDef = param.Definition as InternalDefinition;
TaskDialog.Show("Parameters",
$"{paramDef.Name} parameter of type {paramDef.UnitType} with builtinparameer {paramDef.BuiltInParameter}");
}
return(Result.Succeeded);
}
catch (Exception e)
{
message = e.Message;
return(Result.Failed);
}
}
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);
}
}
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 MyFamilyParameter(FamilyParameter param)
{
List_AssociatedParameters = new List <MyParameter>();
InternalDefinition def = param.Definition as InternalDefinition;
Name = def.Name;
if (param.IsShared)
{
ParamType = MyParameterType.Shared;
}
else
{
if (def.BuiltInParameter == BuiltInParameter.INVALID)
{
ParamType = MyParameterType.Family;
}
else
{
ParamType = MyParameterType.Builtin;
}
}
IsInstance = param.IsInstance;
HaveFormula = param.IsDeterminedByFormula;
Formula = param.Formula;
IsReporting = param.IsReporting;
foreach (Parameter asparam in param.AssociatedParameters)
{
MyParameter myasparam = new MyParameter(asparam, false);
List_AssociatedParameters.Add(myasparam);
}
Units = Enum.GetName(typeof(StorageType), param.StorageType);
}
static String GetParameterInformation(Parameter para, Document document)
{
string defName = para.Definition.Name + "\t : ";
string defValue = string.Empty;
// Use different method to get parameter data according to the storage type
switch (para.StorageType)
{
case StorageType.Double:
//covert the number into Metric
defValue = para.AsValueString();
break;
case StorageType.ElementId:
//find out the name of the element
Autodesk.Revit.DB.ElementId id = para.AsElementId();
if (id.IntegerValue >= 0)
{
defValue = document.GetElement(id).Name;
}
else
{
defValue = id.IntegerValue.ToString();
}
break;
case StorageType.Integer:
if (ParameterType.YesNo == para.Definition.ParameterType)
{
if (para.AsInteger() == 0)
{
defValue = "False";
}
else
{
defValue = "True";
}
}
else
{
defValue = para.AsInteger().ToString();
}
break;
case StorageType.String:
defValue = para.AsString();
break;
default:
InternalDefinition def = para.Definition as InternalDefinition;
BuiltInParameter bp = def.BuiltInParameter;
defValue = "Unexposed parameter.";
break;
}
return(defName + defValue);
}
public SharedParameterContainer(string Name, Guid ParamGuid, BuiltInParameterGroup ParamGroup, bool IsInstance, InternalDefinition ParamDefinition)
{
name = Name;
paramGroup = ParamGroup;
isInstance = IsInstance;
intDefinition = ParamDefinition;
guid = ParamGuid;
}
public static void DoorElementMySQLPara(Document doc, FilteredElementCollector doorCollector,
System.Data.DataTable dt)
{
foreach (Element ele in doorCollector)
{
FamilyInstance door = ele as FamilyInstance;
Level level = level = doc.GetElement(ele.LevelId) as Level;
FamilySymbol familySymbol =
door.Document.GetElement(door.GetTypeId()) as FamilySymbol;
if (door != null)
{
string bottomheight = null;
string width = null;
string height = null;
string kjcha = null;
string drcha = null;
foreach (Parameter param in door.Parameters)
{
InternalDefinition definition = null;
definition = param.Definition as InternalDefinition;
if (null == definition)
{
continue;
}
if (BuiltInParameter.INSTANCE_SILL_HEIGHT_PARAM == definition.BuiltInParameter)
{
bottomheight = param.AsValueString();
}
}
foreach (Parameter para in familySymbol.ParametersMap)
{
InternalDefinition definition = para.Definition as InternalDefinition;
if (null == definition)
{
continue;
}
if (BuiltInParameter.DOOR_WIDTH == definition.BuiltInParameter)
{
width = para.AsValueString();
}
if (BuiltInParameter.GENERIC_HEIGHT == definition.BuiltInParameter)
{
height = para.AsValueString();
}
if (definition.Name == "框架材质")
{
kjcha = para.AsValueString();
}
if (definition.Name == "门材质")
{
drcha = para.AsValueString();
}
}
CreateDoorMySQLRow(dt, door.Symbol.FamilyName,
level.Name, drcha, kjcha, width, bottomheight, height);
}
}
}
public static void DuctElementExcelPara(Document doc, FilteredElementCollector ductCollector,
System.Data.DataTable dt)
{
foreach (Element ele in ductCollector)
{
Duct duct = ele as Duct;
if (duct != null)
{
string Olev = null;
double width = 0.0;
double height = 0.0;
double offset = 0.0;
string shuidui = null;
string chuizhidui = null;
string type = null;
foreach (Parameter param in duct.Parameters)
{
InternalDefinition definition = null;
definition = param.Definition as InternalDefinition;
if (null == definition)
{
continue;
}
if (BuiltInParameter.RBS_START_LEVEL_PARAM == definition.BuiltInParameter)
{
Olev = param.AsValueString();
}
if (BuiltInParameter.RBS_CURVE_WIDTH_PARAM == definition.BuiltInParameter)
{
width = param.AsDouble();
}
if (BuiltInParameter.RBS_CURVE_HEIGHT_PARAM == definition.BuiltInParameter)
{
height = param.AsDouble();
}
if (BuiltInParameter.RBS_OFFSET_PARAM == definition.BuiltInParameter)
{
offset = param.AsDouble();
}
if (BuiltInParameter.RBS_CURVE_HOR_OFFSET_PARAM == definition.BuiltInParameter)
{
shuidui = param.AsValueString();
}
if (BuiltInParameter.RBS_CURVE_VERT_OFFSET_PARAM == definition.BuiltInParameter)
{
chuizhidui = param.AsValueString();
}
if (BuiltInParameter.RBS_DUCT_SYSTEM_TYPE_PARAM == definition.BuiltInParameter)
{
type = param.AsValueString();
}
}
CreateDuctEXCELRow(dt, duct.DuctType.Name, Olev,
FeetTomm(width), FeetTomm(height), FeetTomm(offset),
shuidui, chuizhidui, type);
}
}
}
private void GetParameters(ParameterSet parameters)
{
List <string> ParamLst = new List <string>();
List <string> StrlinLst = new List <string>();
List <BuiltInParameter> BPs = new List <BuiltInParameter>();
foreach (Parameter item in parameters)
{
ParamLst.Add(item.Definition.Name);
StrlinLst.Add(item.Definition.Name + " : " + item.AsString());
InternalDefinition Int = item.Definition as InternalDefinition;
BuiltInParameter BP = Int.BuiltInParameter;
BPs.Add(BP);
}
}
public static void RoomElementExcelPara(Document doc, FilteredElementCollector roomCollector, DataTable dt)
{
foreach (Element ele in roomCollector)
{
Room room = ele as Room;
Level level = doc.GetElement(room.LevelId) as Level;
if (room != null)
{
string number = null;
string name = null;
double area = 0.0;
double tpoffset = 0.0;
double bottomoffset = 0.0;
foreach (Parameter param in room.Parameters)
{
InternalDefinition definition = param.Definition as InternalDefinition;
if (null == definition)
{
continue;
}
if (BuiltInParameter.ROOM_NUMBER == definition.BuiltInParameter)
{
number = param.AsString();
}
if (BuiltInParameter.ROOM_NAME == definition.BuiltInParameter)
{
name = param.AsString();
}
if (BuiltInParameter.ROOM_AREA == definition.BuiltInParameter)
{
area = param.AsDouble();
}
if (BuiltInParameter.ROOM_LOWER_OFFSET == definition.BuiltInParameter)
{
bottomoffset = param.AsDouble();
}
if (BuiltInParameter.ROOM_UPPER_OFFSET == definition.BuiltInParameter)
{
tpoffset = param.AsDouble();
}
}
//怎么 又是这里有问题MMP
RoomIntial.
CreateRoomExcelRow(dt, number, name, level.Name, FeetTomm(bottomoffset), FeetTomm(area)
, FeetTomm(tpoffset));
}
}
}
protected internal static Definition GetParameterDefinition(Document doc, string name)
{
BindingMap val = doc.get_ParameterBindings();
DefinitionBindingMapIterator val2 = val.ForwardIterator();
val2.Reset();
while (val2.MoveNext())
{
InternalDefinition val3 = val2.get_Key();
if (val3.get_Name().Equals(name))
{
return(val3);
}
}
return(null);
}
public static bool TryGetElementBinding(this Document document, string name, out InternalDefinition internalDefinition, out ElementBinding elementBinding)
{
internalDefinition = null;
elementBinding = null;
if (document == null || document.ParameterBindings == null || string.IsNullOrEmpty(name))
{
return(false);
}
DefinitionBindingMapIterator definitionBindingMapIterator = document.ParameterBindings.ForwardIterator();
if (definitionBindingMapIterator == null)
{
return(false);
}
while (definitionBindingMapIterator.MoveNext())
{
InternalDefinition aInternalDefinition_Temp = definitionBindingMapIterator.Key as InternalDefinition;
if (aInternalDefinition_Temp == null)
{
continue;
}
ElementId elementId = aInternalDefinition_Temp.Id;
if (elementId == null || elementId == Autodesk.Revit.DB.ElementId.InvalidElementId)
{
continue;
}
ParameterElement parameterElement = document.GetElement(elementId) as ParameterElement;
if (parameterElement == null)
{
continue;
}
if (name == parameterElement.Name)
{
elementBinding = (ElementBinding)definitionBindingMapIterator.Current;
internalDefinition = aInternalDefinition_Temp;
return(true);
}
}
return(false);
}
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);
}
internal bool DoesParameterExist(string parameterName)
{
// iterate the procedure over
// all the shared parameters in the document
BindingMap bindingMap = m_doc.ParameterBindings;
DefinitionBindingMapIterator itr = bindingMap.ForwardIterator();
while (itr.MoveNext())
{
InternalDefinition internalDefinition
= itr.Key as InternalDefinition;
if (internalDefinition.Name == parameterName)
{
return(true);
}
}
return(false);
}
Stream(ArrayList data, InternalDefinition internalDef)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(InternalDefinition)));
var values = (BuiltInParameter[])Enum.GetValues(typeof(BuiltInParameter));
string[] allNames = Enum.GetNames(typeof(BuiltInParameter));
var names = new System.Collections.Generic.List <string>();
for (int i = 0; i < values.Length; i++)
{
BuiltInParameter value = values[i];
if ((int)value != (int)internalDef.BuiltInParameter)
{
continue;
}
names.Add(allNames[i]);
}
data.Add(new Snoop.Data.String("Built in param", string.Join(", ", names)));
}
internal void CanVaryBtwGroups(
string parameterName,
bool allowVaryBtwGrps)
{
BindingMap bindingMap = m_doc.ParameterBindings;
DefinitionBindingMapIterator itr = bindingMap.ForwardIterator();
while (itr.MoveNext())
{
InternalDefinition internalDef = itr.Key as InternalDefinition;
if (internalDef.Name == parameterName)
{
using (Transaction t = new Transaction(m_doc)) {
t.Start("Allow varying b/w groups");
internalDef.SetAllowVaryBetweenGroups(m_doc, allowVaryBtwGrps);
t.Commit();
}
}
}
}
public ParameterImpression(Parameter p)
{
ElementId = p.Id.IntegerValue;
IsShared = p.IsShared;
if (p.IsShared)
{
Guid = p.GUID;
}
InternalDefinition definition = (InternalDefinition)p.Definition;
Name = definition.Name;
HashCode = p.Id.GetHashCode();
if (definition.BuiltInParameter == BuiltInParameter.INVALID)
{
IsBuiltIn = false;
}
else
{
IsBuiltIn = true;
BuiltInParameter = definition.BuiltInParameter;
}
}
public MyProjectSharedParameter(Parameter param, Document doc)
{
def = param.Definition;
Name = def.Name;
InternalDefinition intDef = def as InternalDefinition;
if (intDef != null)
{
paramGroup = intDef.ParameterGroup;
}
guid = param.GUID;
ElementBinding elemBind = this.GetBindingByParamName(Name, doc);
foreach (Category cat in elemBind.Categories)
{
categories.Add(cat);
}
}
public ParametersInFamily(Document familyDoc)
{
FamilyManager fMan = familyDoc.FamilyManager;
foreach (FamilyParameter fParam in fMan.Parameters)
{
if (!fParam.IsShared)
{
continue;
}
string name = fParam.Definition.Name;
bool isInstance = fParam.IsInstance;
InternalDefinition def = fParam.Definition as InternalDefinition;
Guid guid = fParam.GUID;
BuiltInParameterGroup paramGroup = fParam.Definition.ParameterGroup;
SharedParameterContainer paramContainer = new SharedParameterContainer(name, guid, paramGroup, isInstance, def);
parameters.Add(paramContainer);
}
}
public static void FloorElementMySQLPara(Document doc, FilteredElementCollector floorCollector, System.Data.DataTable dt)
{
foreach (Element ele in floorCollector)
{
Floor floor = ele as Floor;
Level level = doc.GetElement(floor.LevelId) as Level;
if (floor != null)
{
double thick = 0.0;
double area = 0.0;
double offset = 0.0;
foreach (Parameter param in floor.Parameters)
{
InternalDefinition definition = param.Definition as InternalDefinition;
if (null == definition)
{
continue;
}
if (BuiltInParameter.FLOOR_ATTR_THICKNESS_PARAM == definition.BuiltInParameter)
{
thick = param.AsDouble();
}
if (BuiltInParameter.HOST_AREA_COMPUTED == definition.BuiltInParameter)
{
area = param.AsDouble();
}
if (BuiltInParameter.FLOOR_HEIGHTABOVELEVEL_PARAM == definition.BuiltInParameter)
{
offset = param.AsDouble();
}
}
FloorIntial.
CreateFloorMySQLRow(dt, floor.FloorType.Name, level.Name, FeetTomm(thick), FeetTomm(area)
, FeetTomm(offset));
}
}
}
/// <summary>
/// Method to retrieve filtered project parameters ID by category
/// </summary>
/// <param name="doc"></param>
/// <param name="category"></param>
/// <returns></returns>
public static string[] ProjectParameters(Document doc, string categoryName)
{
List <string> parametersID = new List <string>();
BindingMap map = doc.ParameterBindings;
DefinitionBindingMapIterator it = map.ForwardIterator();
it.Reset();
while (it.MoveNext())
{
ElementBinding eleBinding = it.Current as ElementBinding;
InstanceBinding insBinding = eleBinding as InstanceBinding;
if (insBinding != null && IsInstBindingOfCategory(insBinding, categoryName))
{
Definition def = it.Key;
if (def != null)
{
ExternalDefinition extDef = def as ExternalDefinition;
if (extDef != null)
{
string GUID = extDef.GUID.ToString();
parametersID.Add(GUID);
}
else
{
InternalDefinition intDef = def as InternalDefinition;
string ID = intDef.Id.ToString();
parametersID.Add(ID);
}
}
}
}
return(parametersID.ToArray());
}
Stream(ArrayList data, Definition paramDef)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(Definition)));
data.Add(new Snoop.Data.String("Name", paramDef.Name));
data.Add(new Snoop.Data.String("Parameter type", paramDef.ParameterType.ToString()));
data.Add(new Snoop.Data.String("Parameter group", paramDef.ParameterGroup.ToString()));
ExternalDefinition extDef = paramDef as ExternalDefinition;
if (extDef != null)
{
Stream(data, extDef);
return;
}
InternalDefinition intrnalDef = paramDef as InternalDefinition;
if (intrnalDef != null)
{
Stream(data, intrnalDef);
return;
}
}
Stream(ArrayList data, InternalDefinition internalDef)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(InternalDefinition)));
var values = (BuiltInParameter[])Enum.GetValues(typeof (BuiltInParameter));
string[] allNames = Enum.GetNames(typeof (BuiltInParameter));
var names = new System.Collections.Generic.List<string>();
for (int i = 0; i < values.Length; i++)
{
BuiltInParameter value = values[i];
if ((int) value != (int) internalDef.BuiltInParameter) continue;
names.Add(allNames[i]);
}
data.Add(new Snoop.Data.String("Built in param", string.Join(", ", names)));
}
/// <summary>
/// Cache the parameters for an element's subelement (subelementHandle), allowing quick access later.
/// </summary>
/// <param name="elementId">The element id.</param>
/// <param name="subelementHandle">The subelement ifc handle.</param>
/// <param name="param">The element's parameter that we want to override.</param>
/// <param name="paramVal">The override value.</param>
static public void CacheParameterValuesForSubelementHandle(ElementId elementId, IFCAnyHandle subelementHandle, Parameter param, ParameterValue paramVal)
{
if ((elementId == ElementId.InvalidElementId) ||
(subelementHandle == null) ||
(param == null) ||
(paramVal == null))
{
return;
}
if (IsDuplicateParameter(param))
{
return;
}
Definition paramDefinition = param.Definition;
if (paramDefinition == null)
{
return;
}
// Don't cache parameters that aren't visible to the user.
InternalDefinition internalDefinition = paramDefinition as InternalDefinition;
if (internalDefinition != null && internalDefinition.Visible == false)
{
return;
}
if (string.IsNullOrWhiteSpace(paramDefinition.Name))
{
return;
}
string cleanPropertyName = NamingUtil.RemoveSpaces(paramDefinition.Name);
IDictionary <IFCAnyHandle, ParameterValueSubelementCache> anyHandleParamValMap;
if (!m_SubelementParameterValueCache.TryGetValue(elementId, out anyHandleParamValMap))
{
anyHandleParamValMap = new Dictionary <IFCAnyHandle, ParameterValueSubelementCache>();
m_SubelementParameterValueCache[elementId] = anyHandleParamValMap;
}
ParameterValueSubelementCache paramCache;
if (!anyHandleParamValMap.TryGetValue(subelementHandle, out paramCache))
{
paramCache = new ParameterValueSubelementCache();
anyHandleParamValMap[subelementHandle] = paramCache;
}
ParameterValue cachedParamVal;
if (paramCache.ParameterValueCache.TryGetValue(cleanPropertyName, out cachedParamVal))
{
return;
}
paramCache.ParameterValueCache[cleanPropertyName] = paramVal;
}
/// <summary>
/// Cache the parameters for an element, allowing quick access later.
/// </summary>
/// <param name="id">The element id.</param>
static private void CacheParametersForElement(ElementId id)
{
if (id == ElementId.InvalidElementId)
{
return;
}
if (m_NonIFCParameters.ContainsKey(id))
{
return;
}
IDictionary <BuiltInParameterGroup, ParameterElementCache> nonIFCParameters = new SortedDictionary <BuiltInParameterGroup, ParameterElementCache>();
ParameterElementCache ifcParameters = new ParameterElementCache();
m_NonIFCParameters[id] = nonIFCParameters;
m_IFCParameters[id] = ifcParameters;
Element element = ExporterCacheManager.Document.GetElement(id);
if (element == null)
{
return;
}
ParameterSet parameterIds = element.Parameters;
if (parameterIds.Size == 0)
{
return;
}
// We will do two passes. In the first pass, we will look at parameters in the IFC group.
// In the second pass, we will look at all other groups.
ParameterSetIterator parameterIt = parameterIds.ForwardIterator();
while (parameterIt.MoveNext())
{
Parameter parameter = parameterIt.Current as Parameter;
if (parameter == null)
{
continue;
}
if (IsDuplicateParameter(parameter))
{
continue;
}
Definition paramDefinition = parameter.Definition;
if (paramDefinition == null)
{
continue;
}
// Don't cache parameters that aren't visible to the user.
InternalDefinition internalDefinition = paramDefinition as InternalDefinition;
if (internalDefinition != null && internalDefinition.Visible == false)
{
continue;
}
if (string.IsNullOrWhiteSpace(paramDefinition.Name))
{
continue;
}
string cleanPropertyName = NamingUtil.RemoveSpaces(paramDefinition.Name);
BuiltInParameterGroup groupId = paramDefinition.ParameterGroup;
if (groupId != BuiltInParameterGroup.PG_IFC)
{
ParameterElementCache cacheForGroup = null;
if (!nonIFCParameters.TryGetValue(groupId, out cacheForGroup))
{
cacheForGroup = new ParameterElementCache();
nonIFCParameters[groupId] = cacheForGroup;
}
cacheForGroup.ParameterCache[cleanPropertyName] = parameter;
}
else
{
ifcParameters.ParameterCache[cleanPropertyName] = parameter;
}
}
}
/// <summary>
/// Return number of occurrences of
/// search string in parameter value.
/// </summary>
bool SearchParameter(
SortableBindingList <SearchHit> data,
Element e,
Parameter p,
string bipName,
Regex regex)
{
if (null == p)
{
return(false);
}
if (StorageType.String != p.StorageType)
{
return(false);
}
// Do not search non-visible user-defined
// parameters, e.g. data storage used by
// many applications prior to 2012:
Definition def = p.Definition;
ExternalDefinition extdef = p.Definition
as ExternalDefinition;
if (null != extdef && !extdef.Visible)
{
return(false);
}
InternalDefinition intdef = def
as InternalDefinition;
if (null != intdef && !_searchOptions.StandardParams)
{
return(false);
}
if (null != extdef && !_searchOptions.UserParams)
{
return(false);
}
string s = GetParameterString(e, p);
if (null == s || 0 == s.Length)
{
return(false);
}
string bipName2 = (null == intdef)
? null
: intdef.BuiltInParameter.ToString();
if (null == bipName)
{
bipName = bipName2;
}
else
{
Debug.Assert(!_searchOptions.BuiltInParams ||
bipName.Equals(bipName2),
"expected equal built-in parameter name");
}
bool foundOnParam = false;
MatchCollection matches = regex.Matches(s);
foreach (Match m in matches)
{
if (foundOnParam && 0 == m.Length)
{
// ".*" causes two matches, one at the beginning
// and one ot the end of the search string; the
// second has a length of zero, so we skip it:
continue;
}
++_counters.Hits;
foundOnParam = true;
SearchHit hit = new SearchHit(
e, bipName, def.Name, s, m.Index);
data.Add(hit);
}
++_counters.ParametersSearched;
if (foundOnParam)
{
++_counters.ParametersHit;
}
return(foundOnParam);
}
public static void WindowsElementExcelPara(Document doc, FilteredElementCollector doorCollector,
System.Data.DataTable dt)
{
foreach (Element ele in doorCollector)
{
FamilyInstance windows = ele as FamilyInstance;
Level level = level = doc.GetElement(ele.LevelId) as Level;
FamilySymbol familySymbol =
windows.Document.GetElement(windows.GetTypeId()) as FamilySymbol;
if (windows != null)
{
string bottomheight = null;
string width = null;
string height = null;
string bolicha = null;
string outcha = null;
string intercha = null;
foreach (Parameter param in windows.Parameters)
{
InternalDefinition definition = null;
definition = param.Definition as InternalDefinition;
if (null == definition)
{
continue;
}
if (BuiltInParameter.INSTANCE_SILL_HEIGHT_PARAM == definition.BuiltInParameter)
{
bottomheight = param.AsValueString();
}
}
foreach (Parameter para in familySymbol.ParametersMap)
{
InternalDefinition definition = para.Definition as InternalDefinition;
if (null == definition)
{
continue;
}
if (BuiltInParameter.DOOR_WIDTH == definition.BuiltInParameter)
{
width = para.AsValueString();
}
if (BuiltInParameter.GENERIC_HEIGHT == definition.BuiltInParameter)
{
height = para.AsValueString();
}
if (definition.Name == "玻璃嵌板材质")
{
bolicha = para.AsValueString();
}
if (definition.Name == "框架内部材质")
{
intercha = para.AsValueString();
}
if (definition.Name == "框架内部材质")
{
outcha = para.AsValueString();
}
}
CreateWindowExcelRow(dt, windows.Symbol.FamilyName, level.Name, outcha, intercha,
bolicha, width, bottomheight, height);
}
}
}
Stream(ArrayList data, InternalDefinition internalDef)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(InternalDefinition)));
data.Add(new Snoop.Data.String("Built in param", internalDef.BuiltInParameter.ToString()));
}
private void Stream(ArrayList data, InternalDefinition internalDef)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(InternalDefinition)));
data.Add(new Snoop.Data.String("Built in param", internalDef.BuiltInParameter.ToString()));
}
