public bool IsCommandAvailable(UIApplication a, CategorySet b)
{
if (a.ActiveUIDocument == null) return false;
if (a.ActiveUIDocument.Document == null) return false;
if (a.ActiveUIDocument.Document.IsFamilyDocument) return false;
return true;
}
public bool IsCommandAvailable(
UIApplication applicationData,
CategorySet selectedCategories
)
{
UIDocument uiDoc = applicationData.ActiveUIDocument;
if (uiDoc == null || uiDoc.Document.IsFamilyDocument)
return false;
switch (uiDoc.Document.ActiveView.ViewType)
{
case ViewType.AreaPlan:
case ViewType.CeilingPlan:
case ViewType.EngineeringPlan:
case ViewType.FloorPlan:
return true;
}
return false;
}
/// <summary>
/// This method provides the control over whether an
/// external command is enabled or disabled.
/// </summary>
/// <param name="applicationData">An
/// ApplicationServices.Application object which
/// contains reference to Application needed by
/// external command.</param>
/// <param name="selectedCategories">An list of
/// categories of the elements which have been selected
/// in Revit in the active document, or an empty set if
/// no elements are selected or there is no active
/// document.</param>
/// <returns>Indicates whether Revit should enable or
/// disable the corresponding external command.
/// </returns>
bool IExternalCommandAvailability.IsCommandAvailable(
UIApplication applicationData,
CategorySet selectedCategories)
{
ResourceManager res_mng = new ResourceManager(
GetType());
ResourceManager def_res_mng = new ResourceManager(
typeof(Properties.Resources));
bool result = false;
try
{
// ============================================
// TODO: delete these code rows and put your code
// here.
if (applicationData.ActiveUIDocument != null &&
!selectedCategories.IsEmpty)
{
result = true;
}
// ============================================
}
catch (Exception ex)
{
TaskDialog.Show(def_res_mng.GetString("_Error")
, ex.Message);
result = false;
}
finally
{
res_mng.ReleaseAllResources();
def_res_mng.ReleaseAllResources();
}
return(result);
}
public Result CreateElementBindings(ExternalCommandData commandData)
{
Document doc = commandData.Application.ActiveUIDocument.Document;
Application app = doc.Application;
Autodesk.Revit.Creation.Application ca = doc.Application.Create;
Category pipeCat = doc.Settings.Categories.get_Item(BuiltInCategory.OST_PipeCurves);
//Category fittingCat = doc.Settings.Categories.get_Item(BuiltInCategory.OST_PipeFitting);
//Category accessoryCat = doc.Settings.Categories.get_Item(BuiltInCategory.OST_PipeAccessory);
CategorySet pipeSet = ca.NewCategorySet();
pipeSet.Insert(pipeCat);
//CategorySet elemSet = ca.NewCategorySet();
//elemSet.Insert(fittingCat);
//elemSet.Insert(accessoryCat);
string ExecutingAssemblyPath = System.Reflection.Assembly.GetExecutingAssembly().Location;
string oriFile = app.SharedParametersFilename;
string tempFile = ExecutingAssemblyPath + "Temp.txt";
StringBuilder sbFeedback = new StringBuilder();
string domain = "PIPE";
CreateBinding(domain, tempFile, app, doc, pipeSet, sbFeedback);
//domain = "ELEM";
//CreateBinding(domain, tempFile, app, doc, elemSet, sbFeedback);
//ut.InfoMsg(sbFeedback.ToString());
app.SharedParametersFilename = oriFile;
return(Result.Succeeded);
}
bool CreateKeyParameter(Category category, Document document, string parameterName, ParameterType parameterType, BuiltInParameterGroup parameterGroup, Guid guid)
{
Application application = document.Application;
string temShareDefinitionFilePath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments) + @"/temSharpParam.txt";
string originalShareDefinitionFilePath = application.SharedParametersFilename;
if (File.Exists(temShareDefinitionFilePath))
{
File.Delete(temShareDefinitionFilePath);
}
FileStream fileStream = File.Create(temShareDefinitionFilePath);
fileStream.Close();
application.SharedParametersFilename = temShareDefinitionFilePath;
DefinitionFile definitionFile = application.OpenSharedParameterFile();
DefinitionGroup shareParaGroup = definitionFile.Groups.Create("mySharePara");
ExternalDefinitionCreationOptions definitionOpt = new ExternalDefinitionCreationOptions(parameterName, parameterType);
if (guid != null)
{
definitionOpt.GUID = guid;
}
Definition definition = shareParaGroup.Definitions.Create(definitionOpt);
CategorySet categorySet = new CategorySet();
categorySet.Insert(category);
bool result = document.ParameterBindings.Insert(definition, new TypeBinding(categorySet), parameterGroup);
if (!String.IsNullOrEmpty(originalShareDefinitionFilePath))
{
application.SharedParametersFilename = originalShareDefinitionFilePath;
}
File.Delete(temShareDefinitionFilePath);
return(result);
}
public bool IsCommandAvailable(
UIApplication applicationData,
CategorySet selectedCategories
)
{
UIDocument uiDoc = applicationData.ActiveUIDocument;
if (uiDoc == null || uiDoc.Document.IsFamilyDocument)
{
return(false);
}
switch (uiDoc.Document.ActiveView.ViewType)
{
case ViewType.AreaPlan:
case ViewType.CeilingPlan:
case ViewType.EngineeringPlan:
case ViewType.FloorPlan:
return(true);
}
return(false);
}
public bool BindParameter(Document document)
{
DefinitionFile definitionFile = document.Application.OpenSharedParameterFile();
DefinitionGroup definitionGroup = definitionFile.Groups.get_Item("BROWNIE");
if (definitionGroup == null)
{
return(false);
}
Definition definition = this.GetDefinition(definitionGroup);
CategorySet categorySet = document.Application.Create.NewCategorySet();
Category category = document.Settings.Categories.get_Item(BuiltInCategory.OST_Rooms);
categorySet.Insert(category);
Binding binding;
if (this.InstanceBinding)
{
binding = document.Application.Create.NewInstanceBinding(categorySet);
document.ParameterBindings.Insert(definition, binding, BuiltInParameterGroup.PG_DATA);
}
else
{
binding = document.Application.Create.NewTypeBinding(categorySet);
}
bool flag = document.ParameterBindings.Insert(definition, binding);
if (!flag)
{
flag = document.ParameterBindings.ReInsert(definition, binding);
}
return(flag);
}
/// <summary>
/// Method to check if Instance Binding is of a specific category
/// </summary>
/// <param name="insBinding"></param>
/// <param name="category"></param>
/// <returns></returns>
public static bool IsInstBindingOfCategory(InstanceBinding insBinding, string categoryName)
{
CategorySet catSet = insBinding.Categories;
CategorySetIterator catSetIt = catSet.ForwardIterator();
catSetIt.Reset();
string cat = "";
while (catSetIt.MoveNext())
{
Category category1 = catSetIt.Current as Category;
cat = category1.Name;
}
if (cat != "" && cat == categoryName)
{
return(true);
}
else
{
return(false);
}
}
static public bool AddSharedParameter(
Document doc,
string parameterName,
BuiltInCategory[] categories,
BuiltInParameterGroup group = BuiltInParameterGroup.PG_ADSK_MODEL_PROPERTIES,
bool isIntance = true
)
{
// Проверка параметра на наличие
List <bool> check = new List <bool>();
foreach (BuiltInCategory cat in categories)
{
check.Add(IsParameterInProject(doc, parameterName, cat));
}
if (check.All(x => x == true))
{
return(true);
}
else
{
CategorySet catSet = doc.Application.Create.NewCategorySet();
foreach (BuiltInCategory c in categories)
{
catSet.Insert(doc.Settings.Categories.get_Item(c));
}
try
{
doc.Application.SharedParametersFilename = sharedParameterFilePath;
DefinitionFile spFile = doc.Application.OpenSharedParameterFile();
ExternalDefinition sharedDef = null;
foreach (DefinitionGroup gr in spFile.Groups)
{
foreach (Definition def in gr.Definitions)
{
if (def.Name == parameterName)
{
sharedDef = (ExternalDefinition)def;
}
}
}
if (sharedDef == null)
{
TaskDialog.Show("Ошибка", String.Format("Параметр \"{0}\" отсутствует в файле общих параметров", parameterName));
return(false);
}
ElementBinding bind;
if (isIntance)
{
bind = doc.Application.Create.NewInstanceBinding(catSet);
}
else
{
bind = doc.Application.Create.NewTypeBinding(catSet);
}
bool result = doc.ParameterBindings.Insert(sharedDef, bind, group);
// Если параметр уже существует, но данная категория отсутствует в сете - обновляем сет
if (!result)
{
string realName = GetRealParameterName(doc, sharedDef);
bind = GetParameterBinding(doc, realName);
foreach (Category c in catSet)
{
bind.Categories.Insert(c);
}
bool result2 = doc.ParameterBindings.ReInsert(sharedDef, bind, group);
if (!result2)
{
TaskDialog.Show("Ошибка", String.Format("Произошла ошибка при редактировании привязок существующего параметра \"{0}\"", parameterName));
return(false);
}
}
return(true);
}
catch (Exception e)
{
TaskDialog td = new TaskDialog("Ошибка");
td.MainInstruction = String.Format("Произошла ошибка добавления общего параметра \"{0}\"", parameterName);
td.MainContent = e.ToString();
td.Show();
return(false);
}
}
}
/// <summary>
/// create project parameter
/// source :http://spiderinnet.typepad.com/blog/2011/05/parameter-of-revit-api-31-create-project-parameter.html
/// </summary>
/// <param name="app">revit application</param>
/// <param name="name">revit ui application</param>
/// <param name="type">parameter type</param>
/// <param name="cats">category set</param>
/// <param name="group">parameter group</param>
/// <param name="inst">is instance variable</param>
public void CreateProjectParameter(Application app, string name, ParameterType type, CategorySet cats, BuiltInParameterGroup group, bool instance)
{
string oriFile = app.SharedParametersFilename;
string tempFile = Path.GetTempFileName() + ".txt";
using (File.Create(tempFile)) { }
app.SharedParametersFilename = tempFile;
ExternalDefinitionCreationOptions edc=new ExternalDefinitionCreationOptions(name, type);
ExternalDefinition def = app.OpenSharedParameterFile().Groups.Create("TemporaryDefintionGroup").Definitions.Create(edc) as ExternalDefinition;
app.SharedParametersFilename = oriFile;
File.Delete(tempFile);
Autodesk.Revit.DB.Binding binding = app.Create.NewTypeBinding(cats);
if (instance) binding = app.Create.NewInstanceBinding(cats);
BindingMap map = (new UIApplication(app)).ActiveUIDocument.Document.ParameterBindings;
map.Insert(def, binding, group);
}
/// <inheritdoc /> public bool IsCommandAvailable([NotNull] UIApplication applicationData, [NotNull][ItemNotNull] CategorySet selectedCategories) => true;
public bool IsCommandAvailable(UIApplication applicationData, CategorySet selectedCategories)
{
return(true);
}
/// <summary>
/// Command Availability
/// </summary>
/// <param name="applicationData"></param>
/// <param name="selectedCategories"></param>
/// <returns></returns>
public bool IsCommandAvailable(UIApplication applicationData, CategorySet selectedCategories)
{
return(applicationData.ActiveUIDocument != null);
}
/// <summary>
/// This method takes a category and information
/// about a project parameter and adds a binding
/// to the category for the parameter. It will
/// throw an exception if the parameter is already
/// bound to the desired category. It returns
/// whether or not the API reports that it
/// successfully bound the parameter to the
/// desired category.
/// </summary>
/// <param name="doc">The project document in which the project parameter has been defined</param>
/// <param name="projectParameterData">Information about the project parameter</param>
/// <param name="category">The additional category to which to bind the project parameter</param>
/// <returns></returns>
static bool AddProjectParameterBinding(
Document doc,
ProjectParameterData projectParameterData,
Category category)
{
// Following good SOA practices, first validate incoming parameters
if (doc == null)
{
throw new ArgumentNullException("doc");
}
if (doc.IsFamilyDocument)
{
throw new Exception(
"doc can not be a family document.");
}
if (projectParameterData == null)
{
throw new ArgumentNullException(
"projectParameterData");
}
if (category == null)
{
throw new ArgumentNullException("category");
}
bool result = false;
CategorySet cats = projectParameterData.Binding
.Categories;
if (cats.Contains(category))
{
// It's already bound to the desired category.
// Nothing to do.
string errorMessage = string.Format(
"The project parameter '{0}' is already bound to the '{1}' category.",
projectParameterData.Definition.Name,
category.Name);
throw new Exception(errorMessage);
}
cats.Insert(category);
// See if the parameter is an instance or type parameter.
InstanceBinding instanceBinding
= projectParameterData.Binding as InstanceBinding;
if (instanceBinding != null)
{
// Is an Instance parameter
InstanceBinding newInstanceBinding
= doc.Application.Create
.NewInstanceBinding(cats);
if (doc.ParameterBindings.ReInsert(
projectParameterData.Definition,
newInstanceBinding))
{
result = true;
}
}
else
{
// Is a type parameter
TypeBinding typeBinding
= doc.Application.Create
.NewTypeBinding(cats);
if (doc.ParameterBindings.ReInsert(
projectParameterData.Definition, typeBinding))
{
result = true;
}
}
return(result);
}
public Result Execute(
ExternalCommandData commandData,
ref string message,
ElementSet elements)
{
UIDocument uiDoc = commandData.Application.ActiveUIDocument;
Application app = commandData.Application.Application;
Document doc = uiDoc.Document;
using (Transaction transaction = new Transaction(doc))
{
transaction.Start("PerDocParameter");
// get the current shared params definition file
DefinitionFile sharedParamsFile = SharedParameter.GetSharedParamsFile(app);
if (null == sharedParamsFile)
{
TaskDialog.Show("Per document parameter", "Error getting the shared params file.");
return(Result.Failed);
}
// get or create the shared params group
DefinitionGroup sharedParamsGroup = SharedParameter.GetOrCreateSharedParamsGroup(sharedParamsFile, kParamGroupName);
if (null == sharedParamsGroup)
{
TaskDialog.Show("Per document parameter", "Error getting the shared params group.");
return(Result.Failed);
}
// visible param
Definition docParamDefVisible = SharedParameter.GetOrCreateSharedParamsDefinition(sharedParamsGroup, new ForgeTypeId(SpecTypeId.Number.ToString()), kParamNameVisible, true);
if (null == docParamDefVisible)
{
TaskDialog.Show("Per document parameter", "Error creating visible per-doc parameter.");
return(Result.Failed);
}
// invisible param
Definition docParamDefInvisible = SharedParameter.GetOrCreateSharedParamsDefinition(sharedParamsGroup, new ForgeTypeId(SpecTypeId.Number.ToString()), kParamNameInvisible, false);
if (null == docParamDefInvisible)
{
TaskDialog.Show("Per document parameter", "Error creating invisible per-doc parameter.");
return(Result.Failed);
}
// bind the param
try
{
CategorySet catSet = app.Create.NewCategorySet();
catSet.Insert(doc.Settings.Categories.get_Item(BuiltInCategory.OST_ProjectInformation));
Binding binding = app.Create.NewInstanceBinding(catSet);
doc.ParameterBindings.Insert(docParamDefVisible, binding);
doc.ParameterBindings.Insert(docParamDefInvisible, binding);
}
catch (Exception e)
{
TaskDialog.Show("Per document parameter", "Error binding shared parameter: " + e.Message);
return(Result.Failed);
}
// set the initial values
// get the singleton project info element
Element projInfoElem = GetProjectInfoElem(doc);
if (null == projInfoElem)
{
TaskDialog.Show("Per document parameter", "No project info elem found. Aborting command...");
return(Result.Failed);
}
// for simplicity, access params by name rather than by GUID:
//projInfoElem.get_Parameter(kParamNameVisible).Set(55);
//projInfoElem.get_Parameter(kParamNameInvisible).Set(0);
// 'Autodesk.Revit.DB.Element.get_Parameter(string)' is obsolete:
// 'This property is obsolete in Revit 2015, as more than one parameter can have the same name on a given element.
// Use Element.Parameters to obtain a complete list of parameters on this Element,
// or Element.GetParameters(String) to get a list of all parameters by name,
// or Element.LookupParameter(String) to return the first available parameter with the given name.
// modified code for Revit 2015
projInfoElem.LookupParameter(kParamNameVisible).Set(55);
projInfoElem.LookupParameter(kParamNameInvisible).Set(0);
transaction.Commit();
}
return(Result.Succeeded);
}
/// <summary>
/// Create a new shared parameter
/// </summary>
/// <param name="doc">Document</param>
/// <param name="cat">Category to bind the parameter definition</param>
/// <param name="nameSuffix">Parameter name suffix</param>
/// <param name="typeParameter">Create a type parameter? If not, it is an instance parameter.</param>
/// <returns></returns>
bool CreateSharedParameter(
Document doc,
Category cat,
int nameSuffix,
bool typeParameter)
{
Application app = doc.Application;
Autodesk.Revit.Creation.Application ca
= app.Create;
// get or set the current shared params filename:
string filename
= app.SharedParametersFilename;
if (0 == filename.Length)
{
string path = _filename;
StreamWriter stream;
stream = new StreamWriter(path);
stream.Close();
app.SharedParametersFilename = path;
filename = app.SharedParametersFilename;
}
// get the current shared params file object:
DefinitionFile file
= app.OpenSharedParameterFile();
if (null == file)
{
Util.ErrorMsg(
"Error getting the shared params file.");
return(false);
}
// get or create the shared params group:
DefinitionGroup group
= file.Groups.get_Item(_groupname);
if (null == group)
{
group = file.Groups.Create(_groupname);
}
if (null == group)
{
Util.ErrorMsg(
"Error getting the shared params group.");
return(false);
}
// set visibility of the new parameter:
// Category.AllowsBoundParameters property
// indicates if a category can have user-visible
// shared or project parameters. If it is false,
// it may not be bound to visible shared params
// using the BindingMap. Please note that
// non-user-visible parameters can still be
// bound to these categories.
bool visible = cat.AllowsBoundParameters;
// get or create the shared params definition:
string defname = _defname + nameSuffix.ToString();
Definition definition = group.Definitions.get_Item(
defname);
if (null == definition)
{
//definition = group.Definitions.Create( defname, _deftype, visible ); // 2014
ExternalDefinitionCreationOptions opt
= new ExternalDefinitionCreationOptions(
defname, _deftype);
opt.Visible = visible;
definition = group.Definitions.Create(opt); // 2015
}
if (null == definition)
{
Util.ErrorMsg(
"Error creating shared parameter.");
return(false);
}
// create the category set containing our category for binding:
CategorySet catSet = ca.NewCategorySet();
catSet.Insert(cat);
// bind the param:
try
{
Binding binding = typeParameter
? ca.NewTypeBinding(catSet) as Binding
: ca.NewInstanceBinding(catSet) as Binding;
// we could check if it is already bound,
// but it looks like insert will just ignore
// it in that case:
doc.ParameterBindings.Insert(definition, binding);
// we can also specify the parameter group here:
//doc.ParameterBindings.Insert( definition, binding,
// BuiltInParameterGroup.PG_GEOMETRY );
Debug.Print(
"Created a shared {0} parameter '{1}' for the {2} category.",
(typeParameter ? "type" : "instance"),
defname, cat.Name);
}
catch (Exception ex)
{
Util.ErrorMsg(string.Format(
"Error binding shared parameter to category {0}: {1}",
cat.Name, ex.Message));
return(false);
}
return(true);
}
void f( Document doc )
{
Application app = doc.Application;
DefinitionFile sharedParametersFile
= app.OpenSharedParameterFile();
DefinitionGroup group = sharedParametersFile
.Groups.Create( "Reinforcement" );
Definition def = group.Definitions.Create(
"ReinforcementParameter", ParameterType.Text );
List<BuiltInCategory> bics
= new List<BuiltInCategory>();
//bics.Add(BuiltInCategory.OST_AreaRein);
//bics.Add(BuiltInCategory.OST_FabricAreas);
//bics.Add(BuiltInCategory.OST_FabricReinforcement);
//bics.Add(BuiltInCategory.OST_PathRein);
//bics.Add(BuiltInCategory.OST_Rebar);
bics.Add( BuiltInCategory
.OST_IOSRebarSystemSpanSymbolCtrl );
CategorySet catset = new CategorySet();
foreach( BuiltInCategory bic in bics )
{
catset.Insert(
doc.Settings.Categories.get_Item( bic ) );
}
InstanceBinding binding
= app.Create.NewInstanceBinding( catset );
doc.ParameterBindings.Insert( def, binding,
BuiltInParameterGroup.PG_CONSTRUCTION );
}
/// <summary>
/// Creates new shared parameter if it does not exist and bind it to the type or instance of the objects
/// </summary>
/// <param name="paramType">Type of the parameter</param>
/// <param name="categoriesForParam">Category of elements to bind the parameter to</param>
/// <param name="defaultGroupName">Group name of the parameters</param>
/// <param name="parameterName">Name of the parameter</param>
/// <returns>TRUE if shared parameter is created, FALSE otherwise</returns>
public static bool SetNewSharedParameter(this Element element, ParameterType paramType, CategorySet categoriesForParam, string parameterName, BuiltInParameterGroup group)
{
string defaultGroupName = "4P_imported_parameters"; //this is a hack to avoid multiple parameters with the same name.
if (categoriesForParam == null) return false;
if (categoriesForParam.Size == 0) return false;
foreach (Category cat in categoriesForParam)
{
if (cat == null) return false;
if (!cat.AllowsBoundParameters) return false;
}
Application application = element.Document.Application;
Document document = element.Document;
if (_definitionFile == null)
{
//ask for the location of the shared parameters file
var dialog = new Microsoft.Win32.OpenFileDialog();
dialog.CheckFileExists = false;
dialog.Title = "Set shared pID file...";
dialog.ShowDialog();
string shrFilePath = dialog.FileName;
if (shrFilePath == null)
{
_definitionFile = application.OpenSharedParameterFile();
if (_definitionFile == null) SetSharedParamFileInUserProgramFolder(document);
}
else
{
SetDefinitionFile(element, shrFilePath);
}
}
if (_definitionFile == null) throw new Exception("Definition file must be set before creation of the new parameters.");
DefinitionFile myDefinitionFile = _definitionFile;
// Get parameter or create new one
DefinitionGroups myGroups = myDefinitionFile.Groups;
Definition myDefinition = null;
bool found = false;
foreach (DefinitionGroup gr in myGroups)
{
foreach (Definition def in gr.Definitions)
{
if (def.Name == parameterName)
{
myDefinition = def;
found = true;
break;
}
}
if (found) break;
}
//if there is not such a parameter new one is created in default group
if (myDefinition == null)
{
DefinitionGroup myGroup = myGroups.get_Item(defaultGroupName);
if (myGroup == null)
{
myGroup = myGroups.Create(defaultGroupName);
}
// Create a type definition
myDefinition = myGroup.Definitions.get_Item(parameterName);
if (myDefinition == null)
{
myDefinition = myGroup.Definitions.Create(parameterName, paramType);
}
}
//Create an object of TypeBinding or InstanceBinding according to the Categories and "typeBinding" variable
Binding binding = null;
// Get the BingdingMap of current document.
BindingMap bindingMap = document.ParameterBindings;
binding = bindingMap.get_Item(myDefinition);
bool bindOK = false;
if (!element.CanHaveTypeAssigned() && !(element is Material) && !(element is ProjectInfo))
{
if (binding != null)
{
TypeBinding typeBinding = binding as TypeBinding;
if (typeBinding == null)
throw new Exception("Parameter with this definition already exists and is bound to instances. It cannot be bound to the type at the same time");
foreach (Category cat in categoriesForParam) typeBinding.Categories.Insert(cat);
bindOK = bindingMap.ReInsert(myDefinition, binding, group);
return bindOK;
}
else
{
binding = application.Create.NewTypeBinding(categoriesForParam);
}
}
else
{
if (binding != null)
{
InstanceBinding instBinding = binding as InstanceBinding;
if (instBinding == null)
throw new Exception("Parameter with this definition already exists and is bound to types. It cannot be bound to the instance at the same time");
foreach (Category cat in categoriesForParam) instBinding.Categories.Insert(cat);
bindOK = bindingMap.ReInsert(myDefinition, binding, group);
return bindOK;
}
else
{
binding = application.Create.NewInstanceBinding(categoriesForParam);
}
}
// Bind the definitions to the document
bindOK = bindingMap.Insert(myDefinition, binding, group);
return bindOK;
}
private static void AddCategories(Document doc, CategorySet myCategories, BuiltInCategory cat)
{
Category myCategory = doc.Settings.Categories.get_Item(cat);
myCategories.Insert(myCategory);
}
public Task<List<Category>> GetCategoriesAsync(CategorySet set = CategorySet.All)
{
String query = "select * from Category";
switch (set)
{
case CategorySet.All:
default:
break;
case CategorySet.Active:
query += " where IsActive = 1";
break;
}
return database.QueryAsync<Category>(query);
}
void ProblemAddingParameterBindingForCategory(
Document doc)
{
Application app = doc.Application;
if( null == _spellingErrorCorrector )
{
_spellingErrorCorrector
= new Util.SpellingErrorCorrector( app );
}
DefinitionFile sharedParametersFile
= app.OpenSharedParameterFile();
DefinitionGroup group = sharedParametersFile
.Groups.Create( "Reinforcement" );
//Definition def = group.Definitions.Create( // 2014
// "ReinforcementParameter", ParameterType.Text );
ExternalDefinitionCreationOptions opt
= new ExternalDefinitionCreationOptions(
"ReinforcementParameter", ParameterType.Text );
Definition def = group.Definitions.Create( opt ); // 2015
// To handle both ExternalDefinitonCreationOptions
// and ExternalDefinitionCreationOptions:
def = _spellingErrorCorrector.NewDefinition(
group.Definitions, "ReinforcementParameter",
ParameterType.Text );
List<BuiltInCategory> bics
= new List<BuiltInCategory>();
//bics.Add(BuiltInCategory.OST_AreaRein);
//bics.Add(BuiltInCategory.OST_FabricAreas);
//bics.Add(BuiltInCategory.OST_FabricReinforcement);
//bics.Add(BuiltInCategory.OST_PathRein);
//bics.Add(BuiltInCategory.OST_Rebar);
bics.Add( BuiltInCategory
.OST_IOSRebarSystemSpanSymbolCtrl );
CategorySet catset = new CategorySet();
foreach( BuiltInCategory bic in bics )
{
catset.Insert(
doc.Settings.Categories.get_Item( bic ) );
}
InstanceBinding binding
= app.Create.NewInstanceBinding( catset );
doc.ParameterBindings.Insert( def, binding,
BuiltInParameterGroup.PG_CONSTRUCTION );
}
/// <summary>
/// 创建共享参数
/// </summary>
/// <param name="doc"></param>
/// <param name="app"></param>
/// <returns></returns>
public static bool ShareParameterGenerate(Document doc, Autodesk.Revit.ApplicationServices.Application app)
{
//设置共享参数
string TxtFileName = app.RecordingJournalFilename;
Definition IdDf;
Definition areaDf;
Definition sizeDf;
Definition XDf;
Definition YDf;
Definition ZDf;
string sNametmp = TxtFileName.Substring(0, TxtFileName.LastIndexOf("\\")) + "\\Teplate共享参数.txt";
if (!File.Exists(sNametmp))
{
File.WriteAllText(sNametmp, "", Encoding.Default);
app.SharedParametersFilename = sNametmp;
}
try
{
DefinitionFile dsFile = app.OpenSharedParameterFile();
DefinitionGroup dsGroup = dsFile.Groups.ToList().Where(m => m.Name == "模板信息").First();
IdDf = dsGroup.Definitions.get_Item("HostElemID");
areaDf = dsGroup.Definitions.get_Item("模板面积");
sizeDf = dsGroup.Definitions.get_Item("模板尺寸");
XDf = dsGroup.Definitions.get_Item("X");
YDf = dsGroup.Definitions.get_Item("Y");
ZDf = dsGroup.Definitions.get_Item("Z");
}
catch
{
// 判断 路径是否有效，如果为空，读者可以创建一txt文件
//将路径赋值给app.SharedParametersFilename
DefinitionFile dfile = app.OpenSharedParameterFile();
// 创建一个共享参数分组
DefinitionGroup dg = dfile.Groups.Create("模板信息");
// 参数创建的选项，包括参数名字，参数类型，用户是不是可以修改。。
ExternalDefinitionCreationOptions elemID = new ExternalDefinitionCreationOptions("HostElemID", ParameterType.Integer);
elemID.UserModifiable = false;
ExternalDefinitionCreationOptions TemplateArea = new ExternalDefinitionCreationOptions("模板面积", ParameterType.Area);
TemplateArea.UserModifiable = false;
ExternalDefinitionCreationOptions TemplateSize = new ExternalDefinitionCreationOptions("模板尺寸", ParameterType.Text);
TemplateSize.UserModifiable = false;
ExternalDefinitionCreationOptions X = new ExternalDefinitionCreationOptions("X", ParameterType.Number);
X.UserModifiable = false;
ExternalDefinitionCreationOptions Y = new ExternalDefinitionCreationOptions("Y", ParameterType.Number);
Y.UserModifiable = false;
ExternalDefinitionCreationOptions Z = new ExternalDefinitionCreationOptions("Z", ParameterType.Number);
Z.UserModifiable = false;
// 创建参数
IdDf = dg.Definitions.Create(elemID);
areaDf = dg.Definitions.Create(TemplateArea);
sizeDf = dg.Definitions.Create(TemplateSize);
XDf = dg.Definitions.Create(X);
YDf = dg.Definitions.Create(Y);
ZDf = dg.Definitions.Create(Z);
}
if (IdDf == null || areaDf == null || YDf == null || XDf == null || ZDf == null || sizeDf == null)
{
return(false);
}
// 创建一个Category集合
CategorySet cateSet = app.Create.NewCategorySet();
// 获取墙的category
Category TemplateCate = Category.GetCategory(doc, BuiltInCategory.OST_Parts);
// 在Category集合中加入 模板的category
bool flag = cateSet.Insert(TemplateCate);
// 给 这个Category集合中的Category 创建一个实例绑定
InstanceBinding TemBd = app.Create.NewInstanceBinding(cateSet);
//ElementBinding TemBd = app.Create.NewTypeBinding(cateSet);
// 获取当前Document的BindingMap
BindingMap bmap = doc.ParameterBindings;
//创建共享参数和Category之间的Binding
bmap.Insert(IdDf, TemBd);
bmap.Insert(areaDf, TemBd);
bmap.Insert(sizeDf, TemBd);
bmap.Insert(XDf, TemBd);
bmap.Insert(YDf, TemBd);
bmap.Insert(ZDf, TemBd);
//设置视图，打开组成部分
doc.ActiveView.PartsVisibility = PartsVisibility.ShowPartsOnly;
Material partMat = null;
try
{
partMat = FilterElementList <Material>(doc).Where(m => m.Name == "模板材质").First() as Material;
}
catch
{
partMat = doc.GetElement(Material.Create(doc, "模板材质")) as Material;
partMat.Color = new Color(255, 0, 0);
}
doc.Settings.Categories.get_Item(BuiltInCategory.OST_Parts).Material = partMat;
return(true);
}
/// <summary>
/// Implement this method as an external command for Revit.
/// </summary>
/// <param name="commandData">An object that is passed to the external application
/// which contains data related to the command,
/// such as the application object and active view.</param>
/// <param name="message">A message that can be set by the external application
/// which will be displayed if a failure or cancellation is returned by
/// the external command.</param>
/// <param name="elements">A set of elements to which the external application
/// can add elements that are to be highlighted in case of failure or cancellation.</param>
/// <returns>Return the status of the external command.
/// A result of Succeeded means that the API external method functioned as expected.
/// Cancelled can be used to signify that the user cancelled the external operation
/// at some point. Failure should be returned if the application is unable to proceed with
/// the operation.</returns>
public Autodesk.Revit.UI.Result Execute(
ExternalCommandData commandData, ref string message, Autodesk.Revit.DB.ElementSet elements)
{
Transaction transaction = new Transaction(commandData.Application.ActiveUIDocument.Document, "External Tool");
try
{
transaction.Start();
//Create a clear file as parameter file.
String path = Assembly.GetExecutingAssembly().Location;
int index = path.LastIndexOf("\\");
String newPath = path.Substring(0, index);
newPath += "\\RevitParameters.txt";
if (File.Exists(newPath))
{
File.Delete(newPath);
}
FileStream fs = File.Create(newPath);
fs.Close();
//cache application handle
Application revitApp = commandData.Application.Application;
//prepare shared parameter file
commandData.Application.Application.SharedParametersFilename = newPath;
//Open shared parameter file
DefinitionFile parafile = revitApp.OpenSharedParameterFile();
//get walls category
Category wallCat = commandData.Application.ActiveUIDocument.Document.Settings.Categories.get_Item(BuiltInCategory.OST_Walls);
CategorySet categories = revitApp.Create.NewCategorySet();
categories.Insert(wallCat);
InstanceBinding binding = revitApp.Create.NewInstanceBinding(categories);
//Create a group
DefinitionGroup apiGroup = parafile.Groups.Create("APIGroup");
//Create a visible "VisibleParam" of text type.
ExternalDefinitionCreationOptions ExternalDefinitionCreationOptions1 = new ExternalDefinitionCreationOptions("VisibleParam", ParameterType.Text);
Definition visibleParamDef = apiGroup.Definitions.Create
(ExternalDefinitionCreationOptions1);
;
BindingMap bindingMap = commandData.Application.ActiveUIDocument.Document.ParameterBindings;
bindingMap.Insert(visibleParamDef, binding);
//Create a invisible "InvisibleParam" of text type.
ExternalDefinitionCreationOptions ExternalDefinitionCreationOptions2 = new ExternalDefinitionCreationOptions("InvisibleParam", ParameterType.Text);
Definition invisibleParamDef = apiGroup.Definitions.Create
(ExternalDefinitionCreationOptions2);
bindingMap.Insert(invisibleParamDef, binding);
}
catch (Exception e)
{
transaction.RollBack();
message = e.ToString();
return(Autodesk.Revit.UI.Result.Cancelled);
}
finally
{
transaction.Commit();
}
return(Autodesk.Revit.UI.Result.Succeeded);
}
/// <summary>
/// Create a project parameter
/// </summary>
/// <param name="app"></param>
/// <param name="name"></param>
/// <param name="type"></param>
/// <param name="visible"></param>
/// <param name="cats"></param>
/// <param name="group"></param>
/// <param name="inst"></param>
public static void RawCreateProjectParameter(Autodesk.Revit.ApplicationServices.Application app, string name, ParameterType type, bool visible, CategorySet cats, BuiltInParameterGroup group, bool inst)
{
string oriFile = app.SharedParametersFilename;
string tempFile = Path.GetTempFileName() + ".txt";
using (File.Create(tempFile)) { }
app.SharedParametersFilename = tempFile;
ExternalDefinitionCreationOptions externalDefinitionCreationOptions = new ExternalDefinitionCreationOptions(name, type);
ExternalDefinition def = app.OpenSharedParameterFile().Groups.Create("TemporaryDefintionGroup").Definitions.Create(externalDefinitionCreationOptions) as ExternalDefinition;
app.SharedParametersFilename = oriFile;
File.Delete(tempFile);
Autodesk.Revit.DB.Binding binding = app.Create.NewTypeBinding(cats);
if (inst)
{
binding = app.Create.NewInstanceBinding(cats);
}
BindingMap map = (new UIApplication(app)).ActiveUIDocument.Document.ParameterBindings;
map.Insert(def, binding, group);
}
} // end of PopulateProjectParameterData
#endregion // Private helper methods
public Result Execute(
ExternalCommandData commandData,
ref string message,
ElementSet elements)
{
UIApplication uiapp = commandData.Application;
UIDocument uidoc = uiapp.ActiveUIDocument;
Document doc = uidoc.Document;
if (doc.IsFamilyDocument)
{
message = "The document must be a project document.";
return(Result.Failed);
}
// Get the (singleton) element that is the
// ProjectInformation object. It can only have
// instance parameters bound to it, and it is
// always guaranteed to exist.
Element projectInfoElement
= new FilteredElementCollector(doc)
.OfCategory(BuiltInCategory.OST_ProjectInformation)
.FirstElement();
// Get the first wall type element. It can only
// have type parameters bound to it, and there is
// always guaranteed to be at least one of these.
Element firstWallTypeElement
= new FilteredElementCollector(doc)
.OfCategory(BuiltInCategory.OST_Walls)
.WhereElementIsElementType()
.FirstElement();
CategorySet categories = null;
Parameter foundParameter = null;
// Get the list of information about all project
// parameters, calling our helper method, below.
List <ProjectParameterData> projectParametersData
= GetProjectParameterData(doc);
// In order to be able to query whether or not a
// project parameter is shared or not, and if it
// is shared then what it's GUID is, we must ensure
// it exists in the Parameters collection of an
// element.
// This is because we cannot query this information
// directly from the project parameter bindings
// object.
// So each project parameter will attempt to be
// temporarily bound to a known object so a
// Parameter object created from it will exist
// and can be queried for this additional
// information.
foreach (ProjectParameterData projectParameterData
in projectParametersData)
{
if (projectParameterData.Definition != null)
{
categories = projectParameterData.Binding.Categories;
if (!categories.Contains(projectInfoElement.Category))
{
// This project parameter is not already
// bound to the ProjectInformation category,
// so we must temporarily bind it so we can
// query that object for it.
using (Transaction tempTransaction
= new Transaction(doc))
{
tempTransaction.Start("Temporary");
// Try to bind the project parameter do
// the project information category,
// calling our helper method, below.
if (AddProjectParameterBinding(
doc, projectParameterData,
projectInfoElement.Category))
{
// successfully bound
foundParameter
= projectInfoElement.get_Parameter(
projectParameterData.Definition);
if (foundParameter == null)
{
// Must be a shared type parameter,
// which the API reports that it binds
// to the project information category
// via the API, but doesn't ACTUALLY
// bind to the project information
// category. (Sheesh!)
// So we must use a different, type
// based object known to exist, and
// try again.
if (!categories.Contains(
firstWallTypeElement.Category))
{
// Add it to walls category as we
// did with project info for the
// others, calling our helper
// method, below.
if (AddProjectParameterBinding(
doc, projectParameterData,
firstWallTypeElement.Category))
{
// Successfully bound
foundParameter
= firstWallTypeElement.get_Parameter(
projectParameterData.Definition);
}
}
else
{
// The project parameter was already
// bound to the Walls category.
foundParameter
= firstWallTypeElement.get_Parameter(
projectParameterData.Definition);
}
if (foundParameter != null)
{
PopulateProjectParameterData(
foundParameter,
projectParameterData);
}
else
{
// Wouldn't bind to the walls
// category or wasn't found when
// already bound.
// This should probably never happen?
projectParameterData.IsSharedStatusKnown
= false; // Throw exception?
}
}
else
{
// Found the correct parameter
// instance on the Project
// Information object, so use it.
PopulateProjectParameterData(
foundParameter,
projectParameterData);
}
}
else
{
// The API reports it couldn't bind
// the parameter to the ProjectInformation
// category.
// This only happens with non-shared
// Project parameters, which have no
// GUID anyway.
projectParameterData.IsShared = false;
projectParameterData.IsSharedStatusKnown = true;
}
tempTransaction.RollBack();
}
}
else
{
// The project parameter was already bound
// to the Project Information category.
foundParameter
= projectInfoElement.get_Parameter(
projectParameterData.Definition);
if (foundParameter != null)
{
PopulateProjectParameterData(
foundParameter, projectParameterData);
}
else
{
// This will probably never happen.
projectParameterData.IsSharedStatusKnown
= false; // Throw exception?
}
}
} // Whether or not the Definition object could be found
} // For each original project parameter definition
StringBuilder sb = new StringBuilder();
// Build column headers
sb.AppendLine("PARAMETER NAME\tIS SHARED?\tGUID");
// Add each row.
foreach (ProjectParameterData projectParameterData
in projectParametersData)
{
sb.Append(projectParameterData.Name);
sb.Append("\t");
if (projectParameterData.IsSharedStatusKnown)
{
sb.Append(projectParameterData.IsShared.ToString());
}
else
{
sb.Append("<Unknown>");
}
if (projectParameterData.IsSharedStatusKnown &&
projectParameterData.IsShared)
{
sb.Append("\t");
sb.Append(projectParameterData.GUID);
}
sb.AppendLine();
}
System.Windows.Clipboard.Clear();
System.Windows.Clipboard.SetText(sb.ToString());
TaskDialog resultsDialog = new TaskDialog(
"Results are in the Clipboard");
resultsDialog.MainInstruction
= "Results are in the Clipboard";
resultsDialog.MainContent
= "Paste the clipboard into a spreadsheet "
+ "program to see the results.";
resultsDialog.Show();
return(Result.Succeeded);
}
public async Task<IEnumerable<String>> GetCategoryNamesAsync(CategorySet set = CategorySet.All)
{
IEnumerable<Category> categories = await GetCategoriesAsync(set);
return categories.Select(c => c.Name);
}
public static BindSharedParamResult BindSharedParam(
Document doc,
Category cat,
string paramName,
string grpName,
ParameterType paramType,
bool visible,
bool instanceBinding)
{
try // generic
{
Application app = doc.Application;
// This is needed already here to
// store old ones for re-inserting
CategorySet catSet = app.Create.NewCategorySet();
// Loop all Binding Definitions
// IMPORTANT NOTE: Categories.Size is ALWAYS 1 !?
// For multiple categories, there is really one
// pair per each category, even though the
// Definitions are the same...
DefinitionBindingMapIterator iter
= doc.ParameterBindings.ForwardIterator();
while (iter.MoveNext())
{
Definition def = iter.Key;
ElementBinding elemBind
= (ElementBinding)iter.Current;
// Got param name match
if (paramName.Equals(def.Name,
StringComparison.CurrentCultureIgnoreCase))
{
// Check for category match - Size is always 1!
if (elemBind.Categories.Contains(cat))
{
// Check Param Type
if (paramType != def.ParameterType)
{
return(BindSharedParamResult.eWrongParamType);
}
// Check Binding Type
if (instanceBinding)
{
if (elemBind.GetType() != typeof(InstanceBinding))
{
return(BindSharedParamResult.eWrongBindingType);
}
}
else
{
if (elemBind.GetType() != typeof(TypeBinding))
{
return(BindSharedParamResult.eWrongBindingType);
}
}
// Check Visibility - cannot (not exposed)
// If here, everything is fine,
// ie already defined correctly
return(BindSharedParamResult.eAlreadyBound);
}
// If here, no category match, hence must
// store "other" cats for re-inserting
else
{
foreach (Category catOld
in elemBind.Categories)
{
catSet.Insert(catOld); // 1 only, but no index...
}
}
}
}
// If here, there is no Binding Definition for
// it, so make sure Param defined and then bind it!
DefinitionFile defFile
= GetOrCreateSharedParamsFile(app);
DefinitionGroup defGrp
= GetOrCreateSharedParamsGroup(
defFile, grpName);
Definition definition
= GetOrCreateSharedParamDefinition(
defGrp, paramType, paramName, visible);
catSet.Insert(cat);
InstanceBinding bind = null;
if (instanceBinding)
{
bind = app.Create.NewInstanceBinding(
catSet);
}
else
{
bind = app.Create.NewTypeBinding(catSet);
}
// There is another strange API "feature".
// If param has EVER been bound in a project
// (in above iter pairs or even if not there
// but once deleted), Insert always fails!?
// Must use .ReInsert in that case.
// See also similar findings on this topic in:
// http://thebuildingcoder.typepad.com/blog/2009/09/adding-a-category-to-a-parameter-binding.html
// - the code-idiom below may be more generic:
if (doc.ParameterBindings.Insert(
definition, bind))
{
return(BindSharedParamResult.eSuccessfullyBound);
}
else
{
if (doc.ParameterBindings.ReInsert(
definition, bind))
{
return(BindSharedParamResult.eSuccessfullyBound);
}
else
{
return(BindSharedParamResult.eFailed);
}
}
}
catch (Exception ex)
{
MessageBox.Show(string.Format(
"Error in Binding Shared Param: {0}",
ex.Message));
return(BindSharedParamResult.eFailed);
}
}
/// <summary>
/// Заполняет параметры BDS_RebarHostId, BDS_RebarUniqueHostId, Мрк.МаркаКонструкции, Рзм.ТолщинаОсновы. В случае нескольких элемеетов знчения записываются через разделитель "|"
/// </summary>
/// <param name="rebar"></param>
/// <param name="hostElem"></param>
public static string WriteHostInfoSingleRebar(Autodesk.Revit.ApplicationServices.Application revitApp, CategorySet rebarCatSet, Element rebar, List <Element> hostElements)
{
if (Settings.UseHostId)
{
HashSet <string> hostIds = new HashSet <string>();
foreach (Element hostElem in hostElements)
{
ElementId hostId = hostElem.Id;
string tempid = hostId.IntegerValue.ToString();
hostIds.Add(tempid);
}
Parameter rebarHostIdParam = RebarParametrisation.ParametersSupport.CheckAndAddSharedParameter(rebar, revitApp, rebarCatSet, "BDS_RebarHostId", BuiltInParameterGroup.INVALID, true);
string hostIdString = ConvertHashsetToString(hostIds);
rebarHostIdParam.Set(hostIdString);
}
if (Settings.UseUniqueHostId)
{
HashSet <string> hostUniqIds = new HashSet <string>();
foreach (Element hostElem in hostElements)
{
hostUniqIds.Add(hostElem.UniqueId);
}
Parameter rebarHostUniqueIdParam = RebarParametrisation.ParametersSupport.CheckAndAddSharedParameter(rebar, revitApp, rebarCatSet, "BDS_RebarUniqueHostId", BuiltInParameterGroup.INVALID, true);
string hostUniqueId = ConvertHashsetToString(hostUniqIds);
rebarHostUniqueIdParam.Set(hostUniqueId);
}
if (Settings.UseHostMark)
{
HashSet <string> hostMarks = new HashSet <string>();
foreach (Element hostElem in hostElements)
{
Parameter hostMarkParam = hostElem.get_Parameter(BuiltInParameter.ALL_MODEL_MARK);
string tempMark = hostMarkParam.AsString();
if (string.IsNullOrEmpty(tempMark))
{
return("Не заполнена марка у конструкции: " + hostElem.Id.IntegerValue.ToString() + " в файле " + hostElem.Document.Title);
}
else
{
hostMarks.Add(tempMark);
}
}
string hostMark = ConvertHashsetToString(hostMarks);
ParametersSupport.TryWriteParameter(rebar, "Мрк.МаркаКонструкции", hostMark);
}
if (Settings.UseHostThickness)
{
Parameter thicknessRebarParam = rebar.LookupParameter("Рзм.ТолщинаОсновы");
if (thicknessRebarParam != null)
{
if (!thicknessRebarParam.IsReadOnly)
{
HashSet <double> hostWidths = new HashSet <double>();
foreach (Element hostElem in hostElements)
{
if (hostElem is Wall)
{
Wall hostWall = hostElem as Wall;
hostWidths.Add(hostWall.Width);
}
if (hostElem is Floor)
{
Floor hostFloor = hostElem as Floor;
Parameter thicknessParam = hostFloor.get_Parameter(BuiltInParameter.FLOOR_ATTR_THICKNESS_PARAM);
if (thicknessParam == null)
{
thicknessParam = hostFloor.get_Parameter(BuiltInParameter.FLOOR_ATTR_DEFAULT_THICKNESS_PARAM);
if (thicknessParam == null)
{
hostWidths.Add(0);
}
}
if (thicknessParam != null)
{
hostWidths.Add(thicknessParam.AsDouble());
}
}
}
double hostWidth = 0;
if (hostWidths.Count == 1)
{
hostWidth = hostWidths.First();
}
thicknessRebarParam.Set(hostWidth);
}
}
}
return(string.Empty);
}
public Result Execute(
ExternalCommandData commandData,
ref string message,
ElementSet elements)
{
UIDocument uidoc = commandData.Application.ActiveUIDocument;
Application app = commandData.Application.Application;
Document doc = uidoc.Document;
// Get the current shared params definition file
DefinitionFile sharedParamsFile = GetSharedParamsFile(app);
if (null == sharedParamsFile)
{
message = "Error getting the shared params file.";
return(Result.Failed);
}
// Get or create the shared params group
DefinitionGroup sharedParamsGroup = GetOrCreateSharedParamsGroup(
sharedParamsFile, kSharedParamsGroupAPI);
if (null == sharedParamsGroup)
{
message = "Error getting the shared params group.";
return(Result.Failed);
}
Category cat = doc.Settings.Categories.get_Item(BuiltInCategory.OST_Doors);
// Visibility of the new parameter:
// Category.AllowsBoundParameters property indicates if a category can
// have shared or project parameters. If it is false, it may not be bound
// to shared parameters using the BindingMap. Please note that non-user-visible
// parameters can still be bound to these categories.
bool visible = cat.AllowsBoundParameters;
// Get or create the shared params definition
ForgeTypeId forgeTypeId = new ForgeTypeId(SpecTypeId.Number.ToString());
Definition fireRatingParamDef = GetOrCreateSharedParamsDefinition(
sharedParamsGroup, forgeTypeId, kSharedParamsDefFireRating, visible);
if (null == fireRatingParamDef)
{
message = "Error in creating shared parameter.";
return(Result.Failed);
}
// Create the category set for binding and add the category
// we are interested in, doors or walls or whatever:
CategorySet catSet = app.Create.NewCategorySet();
try
{
catSet.Insert(cat);
}
catch (Exception)
{
message = string.Format(
"Error adding '{0}' category to parameters binding set.",
cat.Name);
return(Result.Failed);
}
using (Transaction transaction = new Transaction(doc))
{
transaction.Start("Bind parameter");
// Bind the param
try
{
Binding binding = app.Create.NewInstanceBinding(catSet);
// We could check if already bound, but looks like Insert will just ignore it in such case
doc.ParameterBindings.Insert(fireRatingParamDef, binding);
transaction.Commit();
}
catch (Exception ex)
{
message = ex.Message;
transaction.RollBack();
return(Result.Failed);
}
}
return(Result.Succeeded);
}
/// <summary>
/// Добавить привязку к категории для параметра проекта
/// </summary>
public static BindSharedParamResult BindSharedParam(Document doc, Element elem, string paramName, Definition definition)
{
try
{
Application app = doc.Application;
//собираю уже добавленные категории для повторной вставки и добавления новой категории
CategorySet catSet = app.Create.NewCategorySet();
// Loop all Binding Definitions
// IMPORTANT NOTE: Categories.Size is ALWAYS 1 !?
// For multiple categories, there is really one
// pair per each category, even though the
// Definitions are the same...
DefinitionBindingMapIterator iter
= doc.ParameterBindings.ForwardIterator();
while (iter.MoveNext())
{
Definition def = iter.Key;
if (!paramName.Equals(def.Name))
{
continue;
}
ElementBinding elemBind
= (ElementBinding)iter.Current;
// Check for category match - Size is always 1!
// If here, no category match, hence must
// store "other" cats for re-inserting
foreach (Category catOld in elemBind.Categories)
{
catSet.Insert(catOld); // 1 only, but no index...
}
}
// If here, there is no Binding Definition for
// it, so make sure Param defined and then bind it!
Category cat = elem.Category;
catSet.Insert(cat);
InstanceBinding bind = app.Create.NewInstanceBinding(catSet);
//используем Insert или ReInsert, что сработает
if (doc.ParameterBindings.Insert(definition, bind))
{
return(BindSharedParamResult.eSuccessfullyBound);
}
else
{
if (doc.ParameterBindings.ReInsert(definition, bind))
{
return(BindSharedParamResult.eSuccessfullyBound);
}
else
{
return(BindSharedParamResult.eFailed);
}
}
}
catch (Exception ex)
{
Autodesk.Revit.UI.TaskDialog.Show("Error", string.Format(
"Error in Binding Shared Param: {0}",
ex.Message));
return(BindSharedParamResult.eFailed);
}
}
/// <summary>
/// Initializes element or type parameter binding.
/// </summary>
/// <param name="uiapp"></param>
/// <param name="elm"></param>
/// <param name="paramPath"></param>
public static void InitParamList(this UIApplication uiapp, Element elm, string paramPath)
{
if (uiapp == null)
{
throw new ArgumentNullException(nameof(uiapp));
}
if (elm == null)
{
throw new ArgumentNullException(nameof(elm));
}
if (paramPath == null)
{
throw new ArgumentNullException(nameof(paramPath));
}
var doc = uiapp.ActiveUIDocument.Document;
var bindingMap = doc.ParameterBindings;
var gs = uiapp.GetGroupList(paramPath);
var elmCtgs = new CategorySet();
elmCtgs.Insert(elm.Category);
foreach (var group in GetGroups(paramPath))
{
var paramGroup = gs.GetGroup(group.GroupName);
foreach (var param in group.Params)
{
var definition = paramGroup.GetDefinition(param.ParamName, param.CanEdit);
var binding = bindingMap.get_Item(definition);
// If the parameter group's name contains type key, it's means type binding.
if (!paramGroup.Name.Contains("Group"))
{
if (binding is InstanceBinding instanceBinding)
{
bindingMap.ReInsert(definition, instanceBinding);
}
else
{
instanceBinding = uiapp.Application.Create.NewInstanceBinding(elmCtgs);
bindingMap.Insert(definition, instanceBinding);
}
}
else
{
if (binding is TypeBinding typeBinding)
{
bindingMap.ReInsert(definition, typeBinding);
}
else
{
typeBinding = uiapp.Application.Create.NewTypeBinding(elmCtgs);
bindingMap.Insert(definition, typeBinding);
}
}
}
}
}
public static global::System.Xml.Schema.XmlSchemaComplexType GetTypedTableSchema(global::System.Xml.Schema.XmlSchemaSet xs)
{
global::System.Xml.Schema.XmlSchemaComplexType type = new global::System.Xml.Schema.XmlSchemaComplexType();
global::System.Xml.Schema.XmlSchemaSequence sequence = new global::System.Xml.Schema.XmlSchemaSequence();
CategorySet ds = new CategorySet();
global::System.Xml.Schema.XmlSchemaAny any1 = new global::System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new decimal(0);
any1.MaxOccurs = decimal.MaxValue;
any1.ProcessContents = global::System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
global::System.Xml.Schema.XmlSchemaAny any2 = new global::System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new decimal(1);
any2.ProcessContents = global::System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
global::System.Xml.Schema.XmlSchemaAttribute attribute1 = new global::System.Xml.Schema.XmlSchemaAttribute();
attribute1.Name = "namespace";
attribute1.FixedValue = ds.Namespace;
type.Attributes.Add(attribute1);
global::System.Xml.Schema.XmlSchemaAttribute attribute2 = new global::System.Xml.Schema.XmlSchemaAttribute();
attribute2.Name = "tableTypeName";
attribute2.FixedValue = "CategoryDataTable";
type.Attributes.Add(attribute2);
type.Particle = sequence;
global::System.Xml.Schema.XmlSchema dsSchema = ds.GetSchemaSerializable();
if (xs.Contains(dsSchema.TargetNamespace))
{
global::System.IO.MemoryStream s1 = new global::System.IO.MemoryStream();
global::System.IO.MemoryStream s2 = new global::System.IO.MemoryStream();
try {
global::System.Xml.Schema.XmlSchema schema = null;
dsSchema.Write(s1);
for (global::System.Collections.IEnumerator schemas = xs.Schemas(dsSchema.TargetNamespace).GetEnumerator(); schemas.MoveNext();)
{
schema = ((global::System.Xml.Schema.XmlSchema)(schemas.Current));
s2.SetLength(0);
schema.Write(s2);
if ((s1.Length == s2.Length))
{
s1.Position = 0;
s2.Position = 0;
for (; ((s1.Position != s1.Length) &&
(s1.ReadByte() == s2.ReadByte()));)
{
;
}
if ((s1.Position == s1.Length))
{
return(type);
}
}
}
}
finally {
if ((s1 != null))
{
s1.Close();
}
if ((s2 != null))
{
s2.Close();
}
}
}
xs.Add(dsSchema);
return(type);
}
/// <summary>
/// Create project parameter from existing shared parameter
/// </summary>
/// <param name="app"></param>
/// <param name="name"></param>
/// <param name="cats"></param>
/// <param name="group"></param>
/// <param name="inst"></param>
public static void RawCreateProjectParameterFromExistingSharedParameter(Autodesk.Revit.ApplicationServices.Application app, string name, CategorySet cats, BuiltInParameterGroup group, bool inst)
{
//Location of the shared parameters
string oriFile = app.SharedParametersFilename;
//My Documents
var newpath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
//Create txt inside my documents
Extract("RenumberParts", newpath, "Resources", "SP_RenumberParts.txt");
//Create variable with the location on SP.txt inside my documents
string tempFile = newpath + @"\SP_RenumberParts.txt";
//Change the location of the shared parameters for the SP location
app.SharedParametersFilename = tempFile;
DefinitionFile defFile = app.OpenSharedParameterFile();
var v = (from DefinitionGroup dg in defFile.Groups
from ExternalDefinition d in dg.Definitions
where d.Name == name
select d);
if (v == null || v.Count() < 1)
{
throw new Exception("Invalid Name Input!wwwww");
}
ExternalDefinition def = v.First();
//Place original SP file
app.SharedParametersFilename = oriFile;
//Delete SP temporary file
System.IO.File.Delete(tempFile);
Autodesk.Revit.DB.Binding binding = app.Create.NewTypeBinding(cats);
if (inst)
{
binding = app.Create.NewInstanceBinding(cats);
}
BindingMap map = (new UIApplication(app)).ActiveUIDocument.Document.ParameterBindings;
map.Insert(def, binding, group);
}
//----------------------------------------------------------
public string Them_Hoac_Xoa_Parameter_Trong_Project(UIApplication uiapp, Document doc)
{
string result = "F";
try
{
Transaction transaction = new Transaction(doc);
transaction.Start("Parameters");
var enums = Enum.GetValues(typeof(BuiltInCategory));
var enums1 = Enum.GetValues(typeof(BuiltInParameterGroup));
var categories = doc.Settings.Categories;
foreach (data_group_share_parameter item in my_group_share_parameter)
{
DefinitionFile parafile = uiapp.Application.OpenSharedParameterFile();
if (parafile != null)
{
DefinitionGroup myGroup = parafile.Groups.get_Item(item.ten_group_parameter);
foreach (data_item_share_parameter subitem in item.Children)
{
if (subitem.exist_parameter == true)
{
//BuiltInParameterGroup builtInParameterGroup = BuiltInParameterGroup.PG_TEXT;
//foreach (BuiltInParameterGroup builtIn in enums1)
//{
// if (builtIn.ToString().Split('_')[0] == subitem.ten_parameter && builtIn != BuiltInParameterGroup.INVALID) builtInParameterGroup = builtIn;
//}
Definition myDefinition_ProductDate = myGroup.Definitions.get_Item(subitem.ten_parameter);
CategorySet myCategories = uiapp.Application.Create.NewCategorySet();
foreach (BuiltInCategory buildCategory in enums)
{
try
{
Category cate = categories.get_Item(buildCategory);
if (cate.AllowsBoundParameters == true && cate.CategoryType.ToString() == "Model")
{
myCategories.Insert(cate);
}
}
catch (Exception)
{
}
}
try
{
BindingMap bindingMap = doc.ParameterBindings;
if (subitem.ten_parameter != "Chiều dày hoàn thiện")
{
InstanceBinding instanceBinding = uiapp.Application.Create.NewInstanceBinding(myCategories);
bindingMap.Insert(myDefinition_ProductDate, instanceBinding);
}
else
{
TypeBinding instanceBinding = uiapp.Application.Create.NewTypeBinding(myCategories);
bindingMap.Insert(myDefinition_ProductDate, instanceBinding);
}
if (my_data_parameter_current.Any(x => x.ten_parameter == subitem.ten_parameter) == false)
{
my_data_parameter_current.Add(new data_parameter()
{
ten_parameter = subitem.ten_parameter
});
}
}
catch (Exception)
{
}
}
else
{
try
{
Definition myDefinition_ProductDate = myGroup.Definitions.get_Item(subitem.ten_parameter);
BindingMap bindingMap = doc.ParameterBindings;
bindingMap.Remove(myDefinition_ProductDate);
data_parameter item_remove = my_data_parameter_current.First(x => x.ten_parameter == subitem.ten_parameter);
if (item_remove != null)
{
my_data_parameter_current.Remove(item_remove);
}
}
catch (Exception)
{
}
}
try
{
if (my_data_parameter_current.Any(x => x.ten_parameter == subitem.ten_parameter) == false)
{
my_data_parameter_need.First(x => x.ten_parameter == subitem.ten_parameter).color = Source.color_error;
}
else
{
my_data_parameter_need.First(x => x.ten_parameter == subitem.ten_parameter).color = Source.color;
}
thong_tin_parameter.Items.Refresh();
}
catch (Exception)
{
}
}
}
else
{
MessageBox.Show("Not found share parameter file!!!", "ERROR", MessageBoxButton.OK, MessageBoxImage.Error);
}
}
result = "S";
transaction.Commit();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
return(result);
}
public bool IsCommandAvailable(UIApplication a, CategorySet b)
{
return(true);
}
bool IExternalCommandAvailability.IsCommandAvailable(UIApplication applicationData, CategorySet selectedCategories) => true;
/***************************************************/
/**** Public methods ****/
/***************************************************/
public static Definition SharedParameter(Document document, string parameterName, ParameterType parameterType, string parameterGroup, bool instance, IEnumerable <Category> categories)
{
// Inspired by https://github.com/DynamoDS/DynamoRevit/blob/master/src/Libraries/RevitNodes/Elements/Parameter.cs
if (categories != null && !categories.Any())
{
BH.Engine.Reflection.Compute.RecordError($"Parameter {parameterName} of type {LabelUtils.GetLabelFor(parameterType)} could not be created because no category bindings were provided.");
return(null);
}
// get current shared parameter file
string sharedParameterFile = document.Application.SharedParametersFilename;
// if the file does not exist, throw an error
if (string.IsNullOrWhiteSpace(sharedParameterFile) || !System.IO.File.Exists(sharedParameterFile))
{
BH.Engine.Reflection.Compute.RecordError("The shared parameters file specified in the document does not exist.");
return(null);
}
// Create new parameter group if it does not exist yet
DefinitionGroup groupDef = document.Application.OpenSharedParameterFile().Groups.get_Item(parameterGroup);
if (groupDef == null)
{
try
{
groupDef = document.Application.OpenSharedParameterFile().Groups.Create(parameterGroup);
}
catch
{
BH.Engine.Reflection.Compute.RecordError("New group could not be created in the active document's shared parameter file. Please try using an existing group or unlocking the shared parameter file.");
return(null);
}
}
// If the parameter definition does exist return it
bool bindings = false;
Definition def = groupDef.Definitions.get_Item(parameterName);
if (def != null)
{
if (document.ParameterBindings.Contains(def))
{
BH.Engine.Reflection.Compute.RecordWarning($"Parameter {parameterName} already exists in group {parameterGroup}. It already has category bindings, they were not updated - please make sure they are correct.");
bindings = true;
}
else
{
BH.Engine.Reflection.Compute.RecordWarning($"Parameter {parameterName} already exists in group {parameterGroup}. It did not have any category bindings, so input bindings were applied.");
}
}
else
{
def = groupDef.Definitions.Create(new ExternalDefinitionCreationOptions(parameterName, parameterType)) as ExternalDefinition;
}
if (!bindings)
{
// Apply instance or type binding
CategorySet paramCategories = (categories == null) ? document.CategoriesWithBoundParameters() : Create.CategorySet(document, categories);
Binding bin = (instance) ?
(Binding)document.Application.Create.NewInstanceBinding(paramCategories) :
(Binding)document.Application.Create.NewTypeBinding(paramCategories);
document.ParameterBindings.Insert(def, bin);
}
return(def);
}
public virtual bool IsCommandAvailable(UIApplication applicationData, CategorySet selectedCategories)
{
return(applicationData?.ActiveUIDocument?.Document?.IsValidObject ?? false);
}
public static bool AddProjectParameter(this Document document, ExternalDefinitionCreationOptions externalDefinitionCreationOptions, IEnumerable <BuiltInCategory> builtInCategories, bool instance, BuiltInParameterGroup builtInParameterGroup)
{
if (document == null || externalDefinitionCreationOptions == null || builtInCategories == null)
{
return(false);
}
string name = externalDefinitionCreationOptions.Name;
if (string.IsNullOrWhiteSpace(name))
{
return(false);
}
CategorySet categorySet = Create.CategorySet(document, builtInCategories);
if (categorySet == null || categorySet.Size == 0)
{
return(false);
}
ElementBinding elementBinding = null;
if (Query.TryGetElementBinding(document, externalDefinitionCreationOptions.Name, out InternalDefinition internalDefinition, out elementBinding))
{
return(false);
}
Autodesk.Revit.ApplicationServices.Application application = new UIDocument(document).Application.Application;
bool result = false;
string path = System.IO.Path.GetTempFileName();
try
{
using (SharedParameterFileWrapper sharedParameterFileWrapper = new SharedParameterFileWrapper(application))
{
Definition definition = sharedParameterFileWrapper.Create(System.IO.Path.GetRandomFileName(), externalDefinitionCreationOptions);
if (definition != null)
{
if (instance)
{
elementBinding = application.Create.NewInstanceBinding(categorySet);
}
else
{
elementBinding = application.Create.NewTypeBinding(categorySet);
}
if (elementBinding != null)
{
result = document.ParameterBindings.Insert(definition, elementBinding, builtInParameterGroup);
}
}
}
}
catch (Exception exception)
{
}
finally
{
if (System.IO.File.Exists(path))
{
System.IO.File.Delete(path);
}
}
return(result);
}
/// <summary>
/// Command Availability
/// </summary>
/// <param name="applicationData"></param>
/// <param name="selectedCategories"></param>
/// <returns></returns>
public bool IsCommandAvailable(UIApplication applicationData, CategorySet selectedCategories)
{
return applicationData.ActiveUIDocument != null;
}