private void FindPhase(ParameterProperties pp, bool isFirstParam)
{
try
{
foreach (ElementId eId in pp.ElementIDValues)
{
if (phases.ContainsKey(eId.IntegerValue))
{
Phase phase = phases[eId.IntegerValue];
if (isFirstParam)
{
cmbValue1.Items.Add(phase.Name);
}
else
{
cmbValue2.Items.Add(phase.Name);
}
}
}
}
catch (Exception ex)
{
string message = ex.Message;
}
}
private void FindWorkset(ParameterProperties pp, bool isFirstParam)
{
try
{
foreach (int worksetId in pp.IntValues)
{
if (worksets.ContainsKey(worksetId))
{
Workset workset = worksets[worksetId];
if (isFirstParam)
{
cmbValue1.Items.Add(workset.Name);
}
else
{
cmbValue2.Items.Add(workset.Name);
}
}
}
}
catch (Exception ex)
{
string message = ex.Message;
}
}
private void CollectParameterValues(Element element)
{
try
{
if (null != element.Category)
{
Category category = element.Category;
Dictionary <int, ParameterProperties> paramDictionary = new Dictionary <int, ParameterProperties>();
if (parameterMaps.ContainsKey(category.Id.IntegerValue))
{
paramDictionary = parameterMaps[category.Id.IntegerValue];
foreach (Parameter param in element.Parameters)
{
if (param.StorageType == StorageType.ElementId)
{
if (param.Id.IntegerValue != (int)BuiltInParameter.PHASE_CREATED && param.Id.IntegerValue != (int)BuiltInParameter.PHASE_DEMOLISHED)
{
continue;
}
}
if (paramDictionary.ContainsKey(param.Id.IntegerValue))
{
//paramDictionary[param.Id.IntegerValue].AddValue(param);
paramDictionary.Remove(param.Id.IntegerValue);
}
ParameterProperties pp = new ParameterProperties(param);
pp.AddValue(param);
paramDictionary.Add(pp.ParamId, pp);
}
parameterMaps.Remove(category.Id.IntegerValue);
}
else
{
foreach (Parameter param in element.Parameters)
{
if (param.StorageType == StorageType.ElementId)
{
if (param.Id.IntegerValue != (int)BuiltInParameter.PHASE_CREATED && param.Id.IntegerValue != (int)BuiltInParameter.PHASE_DEMOLISHED)
{
continue;
}
}
if (param.Definition.Name.Contains("Extensions."))
{
continue;
}
if (!paramDictionary.ContainsKey(param.Id.IntegerValue))
{
ParameterProperties pp = new ParameterProperties(param);
pp.AddValue(param);
paramDictionary.Add(pp.ParamId, pp);
}
}
}
parameterMaps.Add(category.Id.IntegerValue, paramDictionary);
}
}
catch (Exception ex)
{
MessageBox.Show("Failed to collect parameter information.\n" + ex.Message, "Collect Parameter Values", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
private ElementFilter CreateParamFilter(int paramId, string strOperator, string paramValue, bool emptyValue)
{
try
{
ParameterProperties pp = selectedParameters[paramId];
ParameterValueProvider pvp = new ParameterValueProvider(new ElementId(pp.ParamId));
switch (pp.ParamStorageType)
{
case StorageType.ElementId:
if (pp.ParamName == "Phase Created" || pp.ParamName == "Phase Demolished")
{
FilterNumericRuleEvaluator fnre1 = new FilterNumericEquals();
var phaseId = from phase in phases where phase.Value.Name == paramValue select phase.Key;
int pId = phaseId.First();
ElementId ruleValId = new ElementId(pId);
FilterRule filterRule1 = new FilterElementIdRule(pvp, fnre1, ruleValId);
if (strOperator == "does not equal")
{
return(new ElementParameterFilter(filterRule1, true));
}
else
{
return(new ElementParameterFilter(filterRule1));
}
}
return(null);
case StorageType.Double:
if (emptyValue)
{
FilterNumericRuleEvaluator fnre = new FilterNumericGreater();
FilterDoubleRule doubleRule = new FilterDoubleRule(pvp, fnre, 0, double.Epsilon);
return(new ElementParameterFilter(doubleRule, true));
}
FilterNumericRuleEvaluator fnre2 = FindFilterNumericRuleEvaluator(strOperator);
double dblValue = 0;
if (!string.IsNullOrEmpty(paramValue))
{
double.TryParse(paramValue, out dblValue);
}
FilterRule filterRule2 = new FilterDoubleRule(pvp, fnre2, dblValue, double.Epsilon);
if (strOperator == "does not equal")
{
return(new ElementParameterFilter(filterRule2, true));
}
else
{
return(new ElementParameterFilter(filterRule2));
}
case StorageType.Integer:
if (emptyValue)
{
FilterNumericRuleEvaluator fnre = new FilterNumericGreater();
FilterIntegerRule integerRule = new FilterIntegerRule(pvp, fnre, 0);
return(new ElementParameterFilter(integerRule, true));
}
FilterNumericRuleEvaluator fnre3 = FindFilterNumericRuleEvaluator(strOperator);
int intValue = 0;
if (pp.ParamName == "Workset")
{
var worksetId = from ws in worksets where ws.Value.Name == paramValue select ws.Key;
intValue = worksetId.First();
}
else if (!string.IsNullOrEmpty(paramValue))
{
int.TryParse(paramValue, out intValue);
}
FilterRule filterRule3 = new FilterIntegerRule(pvp, fnre3, intValue);
if (strOperator == "does not equal")
{
return(new ElementParameterFilter(filterRule3, true));
}
else
{
return(new ElementParameterFilter(filterRule3));
}
case StorageType.String:
if (emptyValue)
{
FilterStringRuleEvaluator fsre = new FilterStringGreater();
FilterStringRule stringRule = new FilterStringRule(pvp, fsre, "", false);
return(new ElementParameterFilter(stringRule, true));
}
FilterStringRuleEvaluator fnre4 = FindFilterStringRuleEvaluator(strOperator);
string strValue = paramValue;
FilterStringRule filterRule4 = new FilterStringRule(pvp, fnre4, strValue, false);
if (strOperator.Contains("does not"))
{
return(new ElementParameterFilter(filterRule4, true));
}
else
{
return(new ElementParameterFilter(filterRule4, false));
}
default:
return(null);
}
}
catch (Exception ex)
{
MessageBox.Show("Failed to create parameter filters.\n" + ex.Message, "CreateParamFilter", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
return(null);
}
private void cmbParamName2_SelectedIndexChanged(object sender, EventArgs e)
{
try
{
cmbOperation2.Items.Clear();
cmbOperation2.ResetText();
cmbValue2.Items.Clear();
cmbValue2.ResetText();
if (null != cmbParamName2.SelectedValue)
{
int paramId = (int)cmbParamName2.SelectedValue;
if (selectedParameters.ContainsKey(paramId))
{
ParameterProperties pp = selectedParameters[paramId];
switch (pp.ParamStorageType)
{
case StorageType.ElementId:
cmbOperation2.Items.Add("equals");
cmbOperation2.Items.Add("does not equal");
cmbOperation2.Items.Add("is greater than");
cmbOperation2.Items.Add("is greater than or equal to");
cmbOperation2.Items.Add("is less than");
cmbOperation2.Items.Add("is less than or equal to");
cmbOperation2.Items.Add("contains");
cmbOperation2.Items.Add("does not contain");
cmbOperation2.Items.Add("begins with");
cmbOperation2.Items.Add("does not begin with");
cmbOperation2.Items.Add("ends with");
cmbOperation2.Items.Add("does not end with");
if (pp.ParamName == "Phase Created" || pp.ParamName == "Phase Demolished")
{
FindPhase(pp, false);
}
break;
case StorageType.Double:
cmbOperation2.Items.Add("equals");
cmbOperation2.Items.Add("does not equal");
cmbOperation2.Items.Add("is greater than");
cmbOperation2.Items.Add("is greater than or equal to");
cmbOperation2.Items.Add("is less than");
cmbOperation2.Items.Add("is less than or equal to");
foreach (double dbl in pp.DoubleValues)
{
cmbValue2.Items.Add(dbl);
}
break;
case StorageType.Integer:
cmbOperation2.Items.Add("equals");
cmbOperation2.Items.Add("does not equal");
cmbOperation2.Items.Add("is greater than");
cmbOperation2.Items.Add("is greater than or equal to");
cmbOperation2.Items.Add("is less than");
cmbOperation2.Items.Add("is less than or equal to");
if (pp.ParamName == "Workset")
{
FindWorkset(pp, false);
}
else
{
foreach (int intVal in pp.IntValues)
{
cmbValue2.Items.Add(intVal);
}
}
break;
case StorageType.String:
cmbOperation2.Items.Add("equals");
cmbOperation2.Items.Add("does not equal");
cmbOperation2.Items.Add("is greater than");
cmbOperation2.Items.Add("is greater than or equal to");
cmbOperation2.Items.Add("is less than");
cmbOperation2.Items.Add("is less than or equal to");
cmbOperation2.Items.Add("contains");
cmbOperation2.Items.Add("does not contain");
cmbOperation2.Items.Add("begins with");
cmbOperation2.Items.Add("does not begin with");
cmbOperation2.Items.Add("ends with");
cmbOperation2.Items.Add("does not end with");
foreach (string strVal in pp.StringValues)
{
cmbValue2.Items.Add(strVal);
}
break;
}
}
}
}
catch (Exception ex)
{
string message = ex.Message;
}
}
private void DisplayParameter()
{
try
{
cmbParamName1.DataSource = null;
cmbParamName2.DataSource = null;
cmbParamName1.Items.Clear();
cmbOperation1.Items.Clear();
cmbValue1.Items.Clear();
cmbParamName2.Items.Clear();
cmbOperation2.Items.Clear();
cmbValue2.Items.Clear();
selectedParameters = new Dictionary <int, ParameterProperties>();
if (listViewCategory.CheckedItems.Count > 0)
{
ListViewItem firstItem = listViewCategory.CheckedItems[0];
if (null != firstItem.Tag)
{
Category category = firstItem.Tag as Category;
if (parameterMaps.ContainsKey(category.Id.IntegerValue))
{
selectedParameters = parameterMaps[category.Id.IntegerValue];
}
}
if (listViewCategory.CheckedItems.Count > 1)
{
for (int i = 1; i < listViewCategory.CheckedItems.Count; i++)
{
ListViewItem item = listViewCategory.CheckedItems[i];
if (null != item.Tag)
{
Category category = item.Tag as Category;
if (parameterMaps.ContainsKey(category.Id.IntegerValue))
{
Dictionary <int, ParameterProperties> paramDictionary = new Dictionary <int, ParameterProperties>();
paramDictionary = parameterMaps[category.Id.IntegerValue];
var commonDictionary = selectedParameters.Keys.Intersect(paramDictionary.Keys).ToDictionary(t => t, t => selectedParameters[t]);
selectedParameters = commonDictionary.ToDictionary(x => x.Key, x => x.Value);
//to fill out union of parameter values
List <int> paramIds = selectedParameters.Keys.ToList();
foreach (int paramId in paramIds)
{
ParameterProperties pp = selectedParameters[paramId];
if (paramDictionary.ContainsKey(paramId))
{
ParameterProperties tempPP = paramDictionary[paramId];
switch (pp.ParamStorageType)
{
case StorageType.ElementId:
pp.ElementIDValues = pp.ElementIDValues.Union(tempPP.ElementIDValues).ToList();
break;
case StorageType.Double:
pp.DoubleValues = pp.DoubleValues.Union(tempPP.DoubleValues).ToList();
break;
case StorageType.Integer:
pp.IntValues = pp.IntValues.Union(tempPP.IntValues).ToList();
break;
case StorageType.String:
pp.StringValues = pp.StringValues.Union(tempPP.StringValues).ToList();
break;
}
}
selectedParameters.Remove(paramId);
selectedParameters.Add(pp.ParamId, pp);
}
}
}
}
}
if (selectedParameters.Count > 0)
{
BindingList <ParameterProperties> paramProperties1 = new BindingList <ParameterProperties>();
BindingList <ParameterProperties> paramProperties2 = new BindingList <ParameterProperties>();
var sortedDictionary = (from entry in selectedParameters orderby entry.Value.ParamName ascending select entry).ToDictionary(pair => pair.Key, pair => pair.Value);
foreach (int paramId in sortedDictionary.Keys)
{
ParameterProperties pp = sortedDictionary[paramId];
paramProperties1.Add(pp);
paramProperties2.Add(pp);
}
cmbParamName1.DataSource = paramProperties1;
cmbParamName1.ValueMember = "ParamId";
cmbParamName1.DisplayMember = "ParamName";
cmbParamName2.DataSource = paramProperties2;
cmbParamName2.ValueMember = "ParamId";
cmbParamName2.DisplayMember = "ParamName";
}
}
}
catch (Exception ex)
{
string message = ex.Message;
}
}
