public Region
( Model model
, ElementWrapper redefinedElement
, global::EA.Diagram masterDiagram
, global::EA.Partition partition
, short regionPos = 0
)
: base(model,redefinedElement.wrappedElement)
{
this.redefinedElement = redefinedElement;
this.masterDiagram = masterDiagram;
this.partition = partition;
this._regionPos = regionPos;
if(redefinedElement is UML.StateMachines.BehaviorStateMachines.StateMachine) {
_stateMachine = redefinedElement as UML.StateMachines.BehaviorStateMachines.StateMachine;
}
else if(redefinedElement is UML.StateMachines.BehaviorStateMachines.State) {
_state = redefinedElement as UML.StateMachines.BehaviorStateMachines.State;
}
else {
throw new ArgumentException("Only StateMachine or State instances are allowed as owners.","owningElement");
}
if(partition != null) {
if(!string.IsNullOrEmpty(partition.Name) &&
partition.Name != "<anonymous>") {
_name = partition.Name;
}
else {
_name = base.name + "Region" + regionPos.ToString();
}
}
else {
_name = base.name + "Region";
}
}
public ElementMappingSet(ElementWrapper rootElement,bool source)
{
this.wrappedElement = rootElement;
this.source = source;
base.name = wrappedElement.name;
base.mappings = this.getMappings().Cast<MP.Mapping>().ToList();
}
public MappingEnd(Element mappedElement,ElementWrapper rootElement)
{
this.mappedEnd = mappedElement;
this.mappingPath = strippedFQN();
if (rootElement != null && mappingPath.StartsWith(rootElement.fqn))
{
this.mappingPath = mappingPath.Remove(0,rootElement.fqn.Length - rootElement.name.Length);
}
}
public static MappingSet createMappingSet(ElementWrapper sourceRoot, MappingSettings settings)
{
//get target mapping root
ElementWrapper targetRootElement = null;
var packageTrace = sourceRoot.getRelationships <Abstraction>().FirstOrDefault(x => x.source.uniqueID == sourceRoot.uniqueID &&
x.target is ElementWrapper &&
x.stereotypes.Any(y => y.name == "trace"));
if (packageTrace != null)
{
targetRootElement = packageTrace.target as ElementWrapper;
}
return(createMappingSet(sourceRoot, targetRootElement, settings));
}
public static List<Mapping> createNewMappings(TSF.UmlToolingFramework.Wrappers.EA.Attribute attribute,string basepath,ElementWrapper targetRootElement)
{
List<Mapping> returnedMappings = new List<Mapping>();
//connectors from owned attributes
foreach (ConnectorWrapper mappedConnector in attribute.relationships.OfType<ConnectorWrapper>())
{
if (! mappedConnector.taggedValues.Any( x => x.name == mappingSourcePathName && x.tagValue.ToString() != basepath))
{
//get the target base path
ConnectorMapping connectorMapping;
var targetTV = mappedConnector.taggedValues.FirstOrDefault(x => x.name == mappingTargetPathName);
string targetBasePath = string.Empty;
if (targetTV != null) targetBasePath = targetTV.tagValue.ToString();
if (! string.IsNullOrEmpty(targetBasePath))
{
connectorMapping = new ConnectorMapping(mappedConnector,basepath,targetBasePath);
}
else
{
connectorMapping = new ConnectorMapping(mappedConnector,basepath,targetRootElement);
}
returnedMappings.Add(connectorMapping);
}
}
//tagged value references from owned attributes
foreach (TaggedValue mappedTaggedValue in attribute.taggedValues.Where(x => x.tagValue is Element) )
{
string mappingSourcePath = getValueForKey(mappingSourcePathName,mappedTaggedValue.comment);
string targetBasePath = getValueForKey(mappingTargetPathName,mappedTaggedValue.comment);
//if not filled in or corresponds to the attributeBasePath
if (string.IsNullOrEmpty(mappingSourcePath) || mappingSourcePath == basepath)
{
TaggedValueMapping tagMapping;
if (! string.IsNullOrEmpty(targetBasePath))
{
tagMapping = new TaggedValueMapping(mappedTaggedValue,basepath,targetBasePath);
}
else
{
tagMapping = new TaggedValueMapping(mappedTaggedValue,basepath,targetRootElement);
}
returnedMappings.Add(tagMapping);
}
}
//add the mappings for the type of the attribute
var attributeType = attribute.type as ElementWrapper;
if (attributeType != null) returnedMappings.AddRange(createOwnedMappings(attributeType,basepath + "." + attribute.name));
return returnedMappings;
}
public void ElementWaitForTimeoutTest6()
{
var element = new ElementWrapper(new MockIWebElement(), browser);
var i = 0;
element.WaitFor((elm) =>
{
if (i++ == 3)
{
return;
}
throw new Exception("Not valid.");
}, 2000, "test timeouted", checkInterval: 100);
}
public static Revit.Elements.Element byName(string name)
{
//exceptions
if (name == null)
{
throw new ArgumentNullException("name");
}
//Gets the Print Setting by name
ViewSheetSet vs = new FilteredElementCollector(DocumentManager.Instance.CurrentDBDocument)
.OfClass(typeof(ViewSheetSet))
.FirstOrDefault(q => q.Name == name) as ViewSheetSet;
var dsElement = ElementWrapper.ToDSType(vs, true);
return(dsElement);
}
private static void PerformSelect2Test(BrowserWrapper browser, ElementWrapper fieldset)
{
var select2 = fieldset.Single(".select2");
var input = select2.First("input");
var result = fieldset.Single(".result");
var addItemsButton = fieldset.ElementAt("button", 0);
var changeSelectionButton = fieldset.ElementAt("button", 1);
var submitButton = fieldset.ElementAt("button", 2);
// verify the selection at the beginning
select2.FindElements("li").ThrowIfDifferentCountThan(2);
result.CheckIfTextEquals("Prague");
// append tag
input.SendKeys("Ne");
input.SendKeys(Keys.Return);
select2.FindElements("li").ThrowIfDifferentCountThan(3);
// submit and check the selection on the server
submitButton.Click().Wait();
// verify the new tag appeared in the result
result.CheckIfTextEquals("Prague,New York");
// check the items offered in the list
input.Click().Wait();
browser.FindElements(".select2-container--open li.select2-results__option").ThrowIfDifferentCountThan(4);
fieldset.Click();
// add new items to the collection
addItemsButton.Click().Wait();
// check the items offered in the list were updated
input.Click().Wait();
browser.FindElements(".select2-container--open li.select2-results__option").ThrowIfDifferentCountThan(5);
// select last item from the list
browser.Last(".select2-container--open li.select2-results__option").Click();
// submit and check the selection on the server
submitButton.Click().Wait();
result.CheckIfTextEquals("Prague,New York,Berlin");
// replace the selection on server
changeSelectionButton.Click().Wait();
submitButton.Click().Wait();
result.CheckIfTextEquals("New York,Paris");
}
private static ElementWrapper UploadFileByA(ElementWrapper element, string fullFileName)
{
element.BrowserWrapper.GetJavaScriptExecutor()
.ExecuteScript("dotvvm.fileUpload.createUploadId(arguments[0])", element.WebElement);
var iframe = element.ParentElement.ParentElement.First("iframe", SelectBy.CssSelector);
element.BrowserWrapper.Browser.SwitchTo().Frame(iframe.WebElement);
var fileInput = element.BrowserWrapper._GetInternalWebDriver()
.FindElement(SelectBy.CssSelector("input[type=file]"));
fileInput.SendKeys(fullFileName);
element.Wait(element.ActionWaitTime);
element.ActivateScope();
return(element);
}
public ConnectorMapping(Element source, Element target, string sourcePath, string targetPath, MappingSettings settings) : base(source, target, sourcePath, targetPath)
{
var sourceAttribute = source as TFS_EA.Attribute;
var targetAttribute = target as TFS_EA.Attribute;
ElementWrapper sourceOwner = sourceAttribute != null ? sourceAttribute.owner as ElementWrapper : source as ElementWrapper;
ElementWrapper targetOwner = targetAttribute != null ? targetAttribute.owner as ElementWrapper: null as ElementWrapper;
if (sourceOwner != null & targetOwner != null)
{
//create the connector
wrappedConnector = sourceOwner.model.factory.createNewElement <UML.Classes.Kernel.Association>
(sourceOwner, string.Empty) as Association;
//set source and target
wrappedConnector.source = source;
wrappedConnector.target = target;
wrappedConnector.save();
}
}
/// <summary>
/// Creates Space from SAM Analytical Space
/// </summary>
/// <param name="space">SAM Analytical Space</param>
/// <param name="convertSettings">convert Settings</param>
/// <search>ToRevit, SAM Analytical Space</search>
public static Revit.Elements.Element ToRevit(SAM.Analytical.Space space, ConvertSettings convertSettings)
{
Document document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
Autodesk.Revit.DB.Element element = SAM.Analytical.Revit.Convert.ToRevit(space, document, convertSettings);
TransactionManager.Instance.TransactionTaskDone();
if (element != null)
{
return(ElementWrapper.ToDSType(element, true));
}
else
{
return(null);
}
}
public static void ScrollTo(this ElementWrapper element)
{
var javascript = @"
function findPosition(element) {
var curtop = 0;
if (element.offsetParent) {
do {
curtop += element.offsetTop;
} while (element = element.offsetParent);
return [curtop];
}
}
window.scroll(0,findPosition(arguments[0]));
";
var executor = element.BrowserWrapper.GetJavaScriptExecutor();
executor.ExecuteScript(javascript, element.WebElement);
}
/// <summary>
/// Creates HostObject from SAM Analytical Panel
/// </summary>
/// <param name="panel">SAM Analytical Panel</param>
/// <search>ToRevit, SAM Analytical Panel</search>
public static Revit.Elements.Element ToRevit(SAM.Analytical.Panel panel, ConvertSettings convertSettings)
{
Document document = DocumentManager.Instance.CurrentDBDocument;
TransactionManager.Instance.EnsureInTransaction(document);
HostObject hostObject = SAM.Analytical.Revit.Convert.ToRevit(panel, document, convertSettings);
TransactionManager.Instance.TransactionTaskDone();
if (hostObject != null)
{
return(ElementWrapper.ToDSType(hostObject, true));
}
else
{
return(null);
}
}
List <Mapping> getMappings()
{
//get the connector mappings
//check if the package has a trace to another package
ElementWrapper targetRootElement = null;
var packageTrace = this.wrappedPackage.relationships.OfType <Abstraction>().FirstOrDefault(x => x.target is Element && x.stereotypes.Any(y => y.name == "trace"));
if (packageTrace != null)
{
targetRootElement = packageTrace.target as ElementWrapper;
}
List <Mapping> returnedMappings = new List <Mapping>();
foreach (var classElement in wrappedPackage.ownedElements.OfType <ElementWrapper>())
{
returnedMappings.AddRange(MappingFactory.createOwnedMappings(classElement, wrappedPackage.name + "." + classElement.name, targetRootElement, true));
}
return(returnedMappings);
}
public static List<Mapping> createOwnedMappings(ElementWrapper ownerElement,string basepath,ElementWrapper targetRootElement)
{
List<Mapping> returnedMappings = new List<Mapping>();
//connectors to an attribute
foreach (ConnectorWrapper mappedConnector in ownerElement.relationships.OfType<ConnectorWrapper>()
.Where(y => y.targetElement is AttributeWrapper))
{
string connectorPath = basepath + "." + getConnectorString(mappedConnector);
var connectorMapping = new ConnectorMapping(mappedConnector,connectorPath,targetRootElement);
returnedMappings.Add(connectorMapping);
}
//loop owned attributes
foreach (TSF.UmlToolingFramework.Wrappers.EA.Attribute ownedAttribute in ownerElement.ownedAttributes)
{
returnedMappings.AddRange(createNewMappings(ownedAttribute,basepath, targetRootElement));
}
return returnedMappings;
}
public Region
(Model model
, ElementWrapper redefinedElement
, global::EA.Diagram masterDiagram
, global::EA.Partition partition
, short regionPos = 0
)
: base(model, redefinedElement.wrappedElement)
{
this.redefinedElement = redefinedElement;
this.masterDiagram = masterDiagram;
this.partition = partition;
this._regionPos = regionPos;
if (redefinedElement is UML.StateMachines.BehaviorStateMachines.StateMachine)
{
_stateMachine = redefinedElement as UML.StateMachines.BehaviorStateMachines.StateMachine;
}
else if (redefinedElement is UML.StateMachines.BehaviorStateMachines.State)
{
_state = redefinedElement as UML.StateMachines.BehaviorStateMachines.State;
}
else
{
throw new ArgumentException("Only StateMachine or State instances are allowed as owners.", "owningElement");
}
if (partition != null)
{
if (!string.IsNullOrEmpty(partition.Name) &&
partition.Name != "<anonymous>")
{
_name = partition.Name;
}
else
{
_name = base.name + "Region" + regionPos.ToString();
}
}
else
{
_name = base.name + "Region";
}
}
/// <summary>
/// Gets the Chart Dash page.
/// </summary>
/// <param name="mainPage">The main page.</param>
/// <returns>Content Page.</returns>
private static ContentPage GetChartDashPage(VisualElement mainPage)
{
var controls = new ContentPage
{
Title = AppResources.PivotItemDashboard,
Icon = "dashboard-32.png"
};
var lstControls = new ListView
{
ItemsSource = Variables.DashList
};
lstControls.ItemSelected += async(sender, e) =>
{
ElementWrapper obj = e.SelectedItem as ElementWrapper;
await mainPage.Navigation.PushAsync(new ChartDashPage(obj.ToString()));
};
controls.Content = lstControls;
return(controls);
}
/// <summary>
/// if it doesn't exist yet then we create it new, if it already exists then we update it
/// </summary>
/// <param name="ownerPackage">the package where the new items should be created</param>
/// <param name = "elementType">the type of element to create for new items</param>
public virtual bool synchronizeToEA(Package ownerPackage, string elementType)
{
//first check if it exists already
string sqlGetExistingElement = @"select o.Object_ID from (t_object o
inner join t_objectproperties tv on o.Object_ID = tv.Object_ID)
where tv.[Property] = 'TFS_ID'
and tv.[Value] = '" + this.ID + "'";
//TODO: get elements by query
var elementToWrap = ownerPackage.model.getElementWrappersByQuery(sqlGetExistingElement).FirstOrDefault();
if (elementToWrap == null)
{
//element does not exist, create a new one
elementToWrap = ownerPackage.addOwnedElement <ElementWrapper>(this.title, elementType);
}
if (elementToWrap != null)
{
this.wrappedElement = elementToWrap;
this.save();
}
//return if this worked
return(elementToWrap != null);
}
public static List <Mapping> createRootMappings(ElementWrapper root, string basepath)
{
//get the owned mappings
var returnedMappings = MappingFactory.createOwnedMappings(root, basepath, false);
//get the mappings of all associated elements
foreach (var assocation in root.relationships
.OfType <Association>()
.Where(x => x.source.Equals(root)))
{
var targetElement = assocation.target as ElementWrapper;
if (targetElement != null)
{
returnedMappings.AddRange(createRootMappings(targetElement, basepath + "." + getConnectorString(assocation)));
}
}
//get the owned mappings of all owned elements
foreach (var ownedElement in root.ownedElements.OfType <ElementWrapper>())
{
returnedMappings.AddRange(createRootMappings(ownedElement, basepath + "." + ownedElement.name));
}
return(returnedMappings);
}
public DiagramObjectWrapper(Model model, ElementWrapper element,
Diagram diagram)
: this(model, diagram.getdiagramObjectForElement(element))
{}
public static List<Mapping> createRootMappings(ElementWrapper root,string basePath)
{
//get the owned mappings
var returnedMappings = MappingFactory.createOwnedMappings(root,basePath);
//get the mappings of all associated elements
foreach (var assocation in root.relationships
.OfType<Association>()
.Where (x => x.source.Equals(root)))
{
var targetElement = assocation.target as ElementWrapper;
if (targetElement != null) returnedMappings.AddRange(createRootMappings(targetElement,basePath + "." + getConnectorString(assocation)));
}
return returnedMappings;
}
/// <summary>
/// Duplicates A Sheet.
/// </summary>
/// <param name="sheet">The Sheet to be Duplicated.</param>
/// <param name="duplicateWithContents">Set to true that Duplicate sheet with contents</param>
/// <param name="duplicateWithView">Set to true that Duplicate sheet with views.</param>
/// <param name="viewDuplicateOption">Enter View Duplicate Option: 0 = Duplicate. 1 = AsDependent. 2 = WithDetailing.</param>
/// <param name="prefix"></param>
/// <param name="suffix">When prefix and suffix are both empty, suffix will set a default value - " - Copy".</param>
/// <returns></returns>
public static Sheet DuplicateSheet(Sheet sheet, bool duplicateWithContents = false, bool duplicateWithView = false, int viewDuplicateOption = 0, string prefix = "", string suffix = "")
{
if (sheet == null)
{
throw new ArgumentNullException(nameof(sheet));
}
ViewDuplicateOption Option = 0;
switch (viewDuplicateOption)
{
case 0:
Option = ViewDuplicateOption.Duplicate;
break;
case 1:
Option = ViewDuplicateOption.AsDependent;
break;
case 2:
Option = ViewDuplicateOption.WithDetailing;
break;
default:
throw new ArgumentException(Properties.Resources.ViewDuplicateOptionOutofRange);
}
if (String.IsNullOrEmpty(prefix) && String.IsNullOrEmpty(suffix))
{
suffix = " - Copy";
}
Sheet newSheet = null;
try
{
RevitServices.Transactions.TransactionManager.Instance.EnsureInTransaction(Application.Document.Current.InternalDocument);
var oldElements = ElementBinder.GetElementsFromTrace <Autodesk.Revit.DB.Element>(Document);
List <ElementId> elementIds = new List <ElementId>();
var newSheetNumber = prefix + sheet.SheetNumber + suffix;
var newSheetName = sheet.SheetName;
List <Autodesk.Revit.DB.Element> TraceElements = new List <Autodesk.Revit.DB.Element>();
if (oldElements != null)
{
foreach (var element in oldElements)
{
elementIds.Add(element.Id);
if (element is ViewSheet)
{
var oldSheet = (element as ViewSheet).ToDSType(false) as Sheet;
if (oldSheet.SheetNumber.Equals(newSheetNumber))
{
if ((duplicateWithView && oldElements.Count() > 1) || (!duplicateWithView && oldElements.Count() == 1))
{
newSheet = oldSheet;
TraceElements.AddRange(oldElements);
}
if (newSheet != null)
{
if (duplicateWithContents)
{
DuplicateSheetAnnotations(sheet, newSheet);
}
else
{
DeleteSheetAnnotations(newSheet);
}
}
}
}
}
if (newSheet == null)
{
Autodesk.Revit.UI.UIDocument uIDocument = new Autodesk.Revit.UI.UIDocument(Document);
var openedViews = uIDocument.GetOpenUIViews().ToList();
var shouldClosedViews = openedViews.FindAll(x => elementIds.Contains(x.ViewId));
if (shouldClosedViews.Count > 0)
{
foreach (var v in shouldClosedViews)
{
if (uIDocument.GetOpenUIViews().ToList().Count() > 1)
{
v.Close();
}
else
{
throw new InvalidOperationException(string.Format(Properties.Resources.CantCloseLastOpenView, v.ToString()));
}
}
}
Document.Delete(elementIds);
}
}
if (newSheet == null && TraceElements.Count == 0)
{
// Create a new Sheet with different SheetNumber
var titleBlockElement = sheet.TitleBlock.First() as FamilyInstance;
FamilySymbol TitleBlock = titleBlockElement.InternalFamilyInstance.Symbol;
FamilyType titleBlockFamilyType = ElementWrapper.Wrap(TitleBlock, true);
if (!CheckUniqueSheetNumber(newSheetNumber))
{
throw new ArgumentException(String.Format(Properties.Resources.SheetNumberExists, newSheetNumber));
}
var viewSheet = Autodesk.Revit.DB.ViewSheet.Create(Document, TitleBlock.Id);
newSheet = new Sheet(viewSheet);
newSheet.InternalSetSheetName(newSheetName);
newSheet.InternalSetSheetNumber(newSheetNumber);
TraceElements.Add(newSheet.InternalElement);
// Copy Annotation Elements from sheet to new sheet by ElementTransformUtils.CopyElements
if (duplicateWithContents)
{
DuplicateSheetAnnotations(sheet, newSheet);
}
if (duplicateWithView)
{
// Copy ScheduleSheetInstance except RevisionSchedule from sheet to new sheet by ElementTransformUtils.CopyElements
DuplicateScheduleSheetInstance(sheet, newSheet);
// Duplicate Viewport in sheet and place on new sheet
TraceElements.AddRange(DuplicateViewport(sheet, newSheet, Option, prefix, suffix));
}
}
ElementBinder.SetElementsForTrace(TraceElements);
RevitServices.Transactions.TransactionManager.Instance.TransactionTaskDone();
}
catch (Exception e)
{
if (newSheet != null)
{
newSheet.Dispose();
}
throw e;
}
return(newSheet);
}
public Mapping(Element sourceElement, Element targetElement,string basepath, ElementWrapper targetRoot)
: this(new MappingEnd(sourceElement,basepath),new MappingEnd(targetElement,targetRoot))
{
}
public ConnectorMapping(ConnectorWrapper wrappedConnector, string basePath, ElementWrapper targetRootElement) : base(wrappedConnector.sourceElement, wrappedConnector.targetElement, basePath, targetRootElement)
{
this.wrappedConnector = wrappedConnector;
}
public TaggedValueMapping(TaggedValue wrappedTaggedValue,string basePath,ElementWrapper targetRootElement)
: base((Element)wrappedTaggedValue.owner,wrappedTaggedValue.tagValue as Element,basePath,targetRootElement)
{
this.wrappedTaggedValue = wrappedTaggedValue;
}
/// <summary>
/// create a mappingSet based on the data in the CSV file
/// </summary>
/// <param name="model">the model that contains the elements</param>
/// <param name="filePath">the path to the CSV file</param>
/// <returns>a mapping set representing the mapping in the file</returns>
public static MappingSet createMappingSet(Model model, string filePath, MappingSettings settings, ElementWrapper sourceRootElement, ElementWrapper targetRootElement)
{
MappingSet newMappingSet = null;
IEnumerable <CSVMappingRecord> mappingRecords;
//read the csv file
using (var textReader = new StreamReader(filePath))
{
var csv = new CSV.CsvReader(textReader, false);
csv.Configuration.RegisterClassMap <CSVMappingRecordMap>();
csv.Configuration.Delimiter = ";";
mappingRecords = csv.GetRecords <CSVMappingRecord>();
}
//create the new mapping set
newMappingSet = createMappingSet(sourceRootElement, targetRootElement, settings);
//remove all existing mappings
//TODO: warn if mappings exist?
foreach (var mapping in newMappingSet.mappings)
{
mapping.delete();
}
//make sure the target node tree has been build
((MappingNode)newMappingSet.target).buildNodeTree();
//now loop the records
foreach (var csvRecord in mappingRecords)
{
EAOutputLogger.log(model, settings.outputName
, $"Parsed source: '{csvRecord.sourcePath}' target: '{csvRecord.targetPath}' logic: '{csvRecord.mappingLogic}'"
, 0, LogTypeEnum.log);
}
return(newMappingSet);
// int i = 1;
//Package rootPackage = null;
//foreach (CSVMappingRecord mappingRecord in parsedFile)
//{
// //find source
// var source = findElement(model, mappingRecord.sourcePath, sourceRootElement);
// //find target
// var target = findElement(model, mappingRecord.targetPath,targetRootElement);
// if (source == null )
// {
// EAOutputLogger.log(model,settings.outputName
// ,string.Format("Could not find element that matches: '{0}'",mappingRecord.sourcePath)
// ,0,LogTypeEnum.error);
// }
// else if( target == null)
// {
// EAOutputLogger.log(model,settings.outputName
// ,string.Format("Could not find element that matches: '{0}'",mappingRecord.targetPath)
// ,0,LogTypeEnum.error);
// }
// else
// {
// //first check if the mappingSet is already created
// if (newMappingSet == null)
// {
// //determine if this should be a PackageMappingSet or an ElementMappingSet
// if (sourceRootElement is Package)
// {
// rootPackage = sourceRootElement as Package;
// //newMappingSet = new PackageMappingSet(sourceRootElement as Package);
// }
// else if (sourceRootElement is ElementWrapper)
// {
// rootPackage = sourceRootElement.owningPackage as Package;
// //newMappingSet = new ElementMappingSet(sourceRootElement as ElementWrapper);
// }
// else
// {
// rootPackage = source.owningPackage as Package;
// //newMappingSet = new PackageMappingSet((Package)source.owningPackage);
// }
// }
// MappingLogic newMappingLogic = null;
// //check if there is any mapping logic
// if (! string.IsNullOrEmpty(mappingRecord.mappingLogic))
// {
// if (settings.useInlineMappingLogic)
// {
// newMappingLogic = new MappingLogic(mappingRecord.mappingLogic);
// }
// else
// {
// //Check fo an existing mapping logic
// newMappingLogic = getExistingMappingLogic(model, settings, mappingRecord.mappingLogic, rootPackage);
// if (newMappingLogic == null)
// {
// var mappingElement = model.factory.createNewElement(rootPackage, "mapping logic " + i,settings.mappingLogicType) as ElementWrapper;
// if (mappingElement != null)
// {
// //increase counter for new mapping element name
// i++;
// mappingElement.notes = mappingRecord.mappingLogic;
// mappingElement.save();
// //create the mappingLogic
// newMappingLogic = new MappingLogic(mappingElement);
// }
// else
// {
// //else we create an inline mapping logic anyway
// newMappingLogic = new MappingLogic(mappingRecord.mappingLogic);
// }
// }
// }
// }
// Mapping newMapping = null;
// var sourceAssociationEnd = source as AssociationEnd;
// var targetAssociationEnd = target as AssociationEnd;
// //create the new mapping
// //we can't create connector mappings for mappings to or from associations so we have to use tagged value mappings for those.
// if (settings.useTaggedValues
// || sourceAssociationEnd != null || targetAssociationEnd != null)
// {
// //if the source or target are associationEnds then we replace them by their association
// if (sourceAssociationEnd != null) source = sourceAssociationEnd.association as Element;
// if (targetAssociationEnd != null) target = targetAssociationEnd.association as Element;
// //newMapping = new TaggedValueMapping(source,target,mappingRecord.sourcePath,mappingRecord.targetPath,settings);
// }
// else
// {
// //newMapping = new ConnectorMapping(source,target,mappingRecord.sourcePath,mappingRecord.targetPath,settings);
// }
// if (newMappingLogic != null) newMapping.mappingLogic = newMappingLogic;
// newMapping.save();
// newMappingSet.addMapping(newMapping);
// }
//}
}
public static List<Mapping> createOwnedMappings(ElementWrapper ownerElement,string basepath)
{
return createOwnedMappings( ownerElement, basepath,null);
}
internal bool isContainedElement(ElementWrapper elementWrapper)
{
if(elementWrapper == null) {
return false;
}
// The element in question must be a direct child of the regions owning element
if(elementWrapper.wrappedElement.ParentID != redefinedElement.wrappedElement.ElementID)
{
return false;
}
if(partition != null)
{
// Check if the element in question resides inside the graphical representation of this region
//--------------------------------------------------------------------------------------------
if(masterDiagram != null)
{
// Get the element in question's graphical representation from the master diagram
global::EA.DiagramObject elementDiagramObject = getMasterDiagramObject(elementWrapper);
if(elementDiagramObject != null)
{
System.Drawing.Rectangle elementRectangle =
new System.Drawing.Rectangle
( elementDiagramObject.left
, System.Math.Abs(elementDiagramObject.top)
, elementDiagramObject.right - elementDiagramObject.left
, System.Math.Abs(elementDiagramObject.bottom) - System.Math.Abs(elementDiagramObject.top)
);
// Get the owning elements graphical region representation from the master diagram
global::EA.DiagramObject owningElementDiagramObject = getMasterDiagramObject(redefinedElement);
if(owningElementDiagramObject != null)
{
int x = owningElementDiagramObject.left;
int y = System.Math.Abs(owningElementDiagramObject.top) + getRegionTopOffset(partition);
int width = owningElementDiagramObject.right - x;
int height = partition.Size;
System.Drawing.Rectangle regionRectangle = new System.Drawing.Rectangle(x,y,width,height);
if(regionRectangle.Contains(elementRectangle))
{
return true;
}
}
}
}
}
else
{
return true;
}
return false;
}
public static void IsElementNotInView(this IOperationRunner <IElementWrapper> operationRunner, ElementWrapper element)
{
var IsElementNotInView = new IsElementNotInViewValidator(element);
operationRunner.Evaluate <UnexpectedElementStateException>(IsElementNotInView);
}
public static List <Mapping> createOwnedMappings(ElementWrapper ownerElement, string basepath, ElementWrapper targetRootElement, bool includeOwnedElements)
{
List <Mapping> returnedMappings = new List <Mapping>();
//connectors to an attribute
foreach (ConnectorWrapper mappedConnector in ownerElement.relationships.OfType <ConnectorWrapper>()
.Where(y => y.targetElement is AttributeWrapper))
{
string connectorPath = basepath + "." + getConnectorString(mappedConnector);
//var connectorMapping = new ConnectorMapping(mappedConnector,connectorPath,targetRootElement);
//returnedMappings.Add(connectorMapping);
}
//loop owned attributes
foreach (TSF.UmlToolingFramework.Wrappers.EA.Attribute ownedAttribute in ownerElement.ownedAttributes)
{
returnedMappings.AddRange(createNewMappings(ownedAttribute, basepath, targetRootElement));
}
//loop owned Elements
if (includeOwnedElements)
{
foreach (var ownedElement in ownerElement.ownedElements.OfType <ElementWrapper>())
{
returnedMappings.AddRange(createOwnedMappings(ownedElement, basepath + "." + ownedElement.name, targetRootElement, includeOwnedElements));
}
}
return(returnedMappings);
}
public ConnectorMapping(ConnectorWrapper wrappedConnector,string basePath,ElementWrapper targetRootElement)
: base(wrappedConnector.sourceElement,wrappedConnector.targetElement,basePath,targetRootElement)
{
this.wrappedConnector = wrappedConnector;
}
/// <summary>
/// constructuro with ElementWrapper
/// </summary>
/// <param name="wrappedElement"></param>
protected WorkItem(WT.Project ownerProject, ElementWrapper wrappedElement) : this(ownerProject)
{
this._wrappedElement = wrappedElement;
}
private void zvyrazniVDiagrameToolStripMenuItem_Click(object sender, System.EventArgs e)
{
try {
if (selectedError.rule.elementType == "Class" || selectedError.rule.elementType == "UseCase" || selectedError.rule.elementType == "Activity")
{
ElementWrapper elementWrapper = new ElementWrapper(selectedError.model, (EA.Element)selectedError.element);
elementWrapper.selectInCurrentDiagram();
}
else
{
ConnectorWrapper connectorWrapper = new ConnectorWrapper(selectedError.model, (EA.Connector)selectedError.element);
connectorWrapper.selectInCurrentDiagram();
}
}
catch (Exception ex) { }
}
public void ElementWaitForTimeoutTest()
{
var element = new ElementWrapper(new MockIWebElement(), browser);
element.WaitFor(elm => false, 2000, "test timeouted");
}
public DoorsNGRequirement(ElementWrapper wrappedelement) : base(wrappedelement)
{
}
public TaggedValueMapping(TaggedValue wrappedTaggedValue, string basePath, ElementWrapper targetRootElement) : base((Element)wrappedTaggedValue.owner, wrappedTaggedValue.tagValue as Element, basePath, targetRootElement)
{
this.wrappedTaggedValue = wrappedTaggedValue;
}
private FormDefinition BuildDefinition(Type type)
{
// Only classes are allowed.
// Primitives should be retrieved from prebuilt definitions.
if (!type.IsClass || typeof(MulticastDelegate).IsAssignableFrom(type.BaseType))
{
return(null);
}
var formDefinition = new FormDefinition(type);
var mode = DefaultFields.AllExcludingReadonly;
var grid = new[] { 1d };
var beforeFormContent = new List <AttrElementTuple>();
var afterFormContent = new List <AttrElementTuple>();
foreach (var attribute in type.GetCustomAttributes())
{
switch (attribute)
{
case ResourceAttribute resource:
formDefinition.Resources.Add(resource.Name, resource.Value is string expr
? (IValueProvider)BoundExpression.Parse(expr)
: new LiteralValue(resource.Value));
break;
case FormAttribute form:
mode = form.Mode;
grid = form.Grid;
if (grid == null || grid.Length < 1)
{
grid = new[] { 1d };
}
break;
case FormContentAttribute contentAttribute:
if (contentAttribute.Placement == Placement.After)
{
afterFormContent.Add(new AttrElementTuple(contentAttribute, contentAttribute.GetElement()));
}
else if (contentAttribute.Placement == Placement.Before)
{
beforeFormContent.Add(new AttrElementTuple(contentAttribute,
contentAttribute.GetElement()));
}
break;
case MetaAttribute meta:
if (!string.IsNullOrEmpty(meta.Name))
{
formDefinition.Metadata[meta.Name] = meta.Value;
}
break;
}
}
beforeFormContent.Sort((a, b) => a.Attr.Position.CompareTo(b.Attr.Position));
afterFormContent.Sort((a, b) => a.Attr.Position.CompareTo(b.Attr.Position));
var gridLength = grid.Length;
// Pass one - get list of valid properties.
var properties = Utilities
.GetProperties(type, mode)
.Select(p => new PropertyInfoWrapper(p))
.ToArray();
// Pass two - build form elements.
var elements = new List <ElementWrapper>();
foreach (var property in properties)
{
var deserializer = TryGetDeserializer(property.PropertyType);
// Query property builders.
var element = Build(property, deserializer);
if (element == null)
{
// Unhandled properties are ignored.
continue;
}
// Pass three - initialize elements.
foreach (var initializer in FieldInitializers)
{
initializer.Initialize(element, property, deserializer);
}
var wrapper = new ElementWrapper(element, property);
// Set layout.
var attr = property.GetCustomAttribute <FieldAttribute>();
if (attr != null)
{
wrapper.Position = attr.Position;
wrapper.Row = attr.Row;
wrapper.Column = attr.Column;
wrapper.ColumnSpan = attr.ColumnSpan;
}
elements.Add(wrapper);
}
// Pass four - order elements.
elements = elements.OrderBy(element => element.Position).ToList();
// Pass five - group rows and calculate layout.
var layout = PerformLayout(grid, elements);
// Pass six - add attached elements.
var rows = new List <FormRow>();
// Before form.
rows.AddRange(CreateRows(beforeFormContent, gridLength));
foreach (var row in layout)
{
var before = new List <AttrElementTuple>();
var after = new List <AttrElementTuple>();
foreach (var element in row.Elements)
{
var property = element.Property;
foreach (var attr in property.GetCustomAttributes <FormContentAttribute>())
{
if (attr.Placement == Placement.Before)
{
before.Add(new AttrElementTuple(attr, attr.GetElement()));
}
else if (attr.Placement == Placement.After)
{
after.Add(new AttrElementTuple(attr, attr.GetElement()));
}
}
}
before.Sort((a, b) => a.Attr.Position.CompareTo(b.Attr.Position));
after.Sort((a, b) => a.Attr.Position.CompareTo(b.Attr.Position));
// Before element.
rows.AddRange(CreateRows(before, gridLength));
// Field row.
var formRow = new FormRow();
formRow.Elements.AddRange(
row.Elements.Select(w =>
{
var inlineElements = w.Property
.GetCustomAttributes <FormContentAttribute>()
.Where(attr => attr.Placement == Placement.Inline)
.Select(attr => new AttrElementTuple(attr, attr.GetElement()))
.OrderBy(tuple => tuple.Attr.Position)
.ToList();
w.Element.LinePosition = (Position)(-1);
if (inlineElements.Count != 0)
{
return(new FormElementContainer(w.Column, w.ColumnSpan,
inlineElements
.Select(t => t.Element)
.Concat(new[] { w.Element })
.ToList()));
}
return(new FormElementContainer(w.Column, w.ColumnSpan, w.Element));
}));
rows.Add(formRow);
// After element.
rows.AddRange(CreateRows(after, gridLength));
}
// After form.
rows.AddRange(CreateRows(afterFormContent, gridLength));
// Wrap up everything.
formDefinition.Grid = grid;
formDefinition.FormRows = rows;
formDefinition.Freeze();
foreach (var element in formDefinition.FormRows.SelectMany(r => r.Elements).SelectMany(c => c.Elements))
{
element.Freeze();
}
return(formDefinition);
}
public MappingLogic(ElementWrapper wrappedElement)
{
this.mappingElement = wrappedElement;
}
public static List <Mapping> createOwnedMappings(ElementWrapper ownerElement, string basepath, bool includeOwnedElements)
{
return(createOwnedMappings(ownerElement, basepath, null, includeOwnedElements));
}
private void SetupPython()
{
if (setupPython)
{
return;
}
IronPythonEvaluator.OutputMarshaler.RegisterMarshaler((Autodesk.Revit.DB.Element element) => ElementWrapper.ToDSType(element, (bool)true));
// Turn off element binding during iron python script execution
IronPythonEvaluator.EvaluationBegin += (a, b, c, d, e) => ElementBinder.IsEnabled = false;
IronPythonEvaluator.EvaluationEnd += (a, b, c, d, e) => ElementBinder.IsEnabled = true;
// register UnwrapElement method in ironpython
IronPythonEvaluator.EvaluationBegin += (a, b, scope, d, e) =>
{
var marshaler = new DataMarshaler();
marshaler.RegisterMarshaler((Revit.Elements.Element element) => element.InternalElement);
marshaler.RegisterMarshaler((Revit.Elements.Category element) => element.InternalCategory);
Func <object, object> unwrap = marshaler.Marshal;
scope.SetVariable("UnwrapElement", unwrap);
};
setupPython = true;
}
private global::EA.DiagramObject getMasterDiagramObject(ElementWrapper elementWrapper)
{
foreach(global::EA.DiagramObject diagramObject in masterDiagram.DiagramObjects)
{
if(diagramObject.ElementID == elementWrapper.wrappedElement.ElementID)
{
return diagramObject;
}
}
return null;
}
/// <summary>
/// Duplicates A view.
/// </summary>
/// <param name="view">The View to be Duplicated</param>
/// <param name="viewDuplicateOption">Enter View Duplicate Option: Duplicate, AsDependent or WithDetailing.</param>
/// <param name="prefix"></param>
/// <param name="suffix"></param>
/// <returns></returns>
public static Revit.Elements.Views.View DuplicateView(View view, string viewDuplicateOption = "Duplicate", string prefix = "", string suffix = "")
{
View newView = null;
if (view == null)
{
throw new ArgumentNullException(nameof(view));
}
if (view is Sheet)
{
throw new ArgumentException(Properties.Resources.DuplicateViewCantApplySheet);
}
ViewDuplicateOption Option = (ViewDuplicateOption)Enum.Parse(typeof(ViewDuplicateOption), viewDuplicateOption);
try
{
RevitServices.Transactions.TransactionManager.Instance.EnsureInTransaction(Application.Document.Current.InternalDocument);
var viewElement = ElementBinder.GetElementFromTrace <Autodesk.Revit.DB.View>(Document);
int count = 0;
string newViewName = "";
if (!String.IsNullOrEmpty(prefix) || !String.IsNullOrEmpty(suffix))
{
newViewName = prefix + view.Name + suffix;
}
Autodesk.Revit.UI.UIDocument uIDocument = new Autodesk.Revit.UI.UIDocument(Document);
var openedViews = uIDocument.GetOpenUIViews().ToList();
if (viewElement != null)
{
count++;
var oldViewName = viewElement.Name;
if (oldViewName.Equals(newViewName))
{
newView = viewElement.ToDSType(false) as View;
}
else
{
count--;
}
}
if (count == 0)
{
if (!CheckUniqueViewName(newViewName))
{
throw new ArgumentException(String.Format(Properties.Resources.ViewNameExists, newViewName));
}
if (view.InternalView.CanViewBeDuplicated(Option))
{
var viewID = view.InternalView.Duplicate(Option);
var viewEle = Document.GetElement(viewID) as Autodesk.Revit.DB.View;
newView = ElementWrapper.ToDSType(viewEle, false) as View;
}
else
{
throw new Exception(String.Format(Properties.Resources.ViewCantBeDuplicated, view.Name));
}
if (!String.IsNullOrEmpty(newViewName))
{
var param = newView.InternalView.get_Parameter(BuiltInParameter.VIEW_NAME);
param.Set(newViewName);
}
if (viewElement != null)
{
var shouldClosedViews = openedViews.FindAll(x => viewElement.Id == x.ViewId);
if (shouldClosedViews.Count > 0)
{
foreach (var v in shouldClosedViews)
{
if (uIDocument.GetOpenUIViews().ToList().Count() > 1)
{
v.Close();
}
else
{
throw new InvalidOperationException(string.Format(Properties.Resources.CantCloseLastOpenView, viewElement.ToString()));
}
}
}
}
}
ElementBinder.CleanupAndSetElementForTrace(Document, newView.InternalElement);
RevitServices.Transactions.TransactionManager.Instance.TransactionTaskDone();
}
catch (Exception e)
{
//if (e is Autodesk.Revit.Exceptions.InvalidOperationException)
// throw e;
if (newView != null)
{
newView.Dispose();
}
throw e;
}
return(newView);
}
/// <summary>
/// Gets the Chart Events page.
/// </summary>
/// <param name="mainPage">The main page.</param>
/// <returns>Content Page.</returns>
private static ContentPage GetChartEventsPage(VisualElement mainPage)
{
var controls = new ContentPage
{
Title = AppResources.OtherItem,
Icon = "project-32.png"
};
var lstControls = new ListView
{
ItemsSource = Variables.OtherList
};
Cell = new DataTemplate(typeof(TextCell));
lstControls.BackgroundColor = Color.FromRgb(255, 255, 255);
Cell.SetBinding(TextCell.TextProperty, "Description");
Cell.SetBinding(TextCell.DetailProperty, "Summary");
Cell.SetValue(TextCell.TextColorProperty, Color.Black);
Cell.SetValue(TextCell.DetailColorProperty, Color.White);
lstControls.ItemTemplate = Cell;
lstControls.ItemSelected += async(sender, e) =>
{
ElementWrapper obj = e.SelectedItem as ElementWrapper;
switch (obj.ToString())
{
case "Click Annotation":
{
await mainPage.Navigation.PushAsync(new Other.ClickAnnotation());
break;
}
case "Snap Cursor ToolTip":
{
await mainPage.Navigation.PushAsync(new Other.SnapCursorToolTip());
break;
}
case "ScrollPager Tool":
{
await mainPage.Navigation.PushAsync(new Other.ScrollPagerTool());
break;
}
case "SubChart Tool":
{
await mainPage.Navigation.PushAsync(new Other.SubChartTool());
break;
}
case "ColorLine Tool":
{
await mainPage.Navigation.PushAsync(new Other.ColorLineTool());
break;
}
}
};
controls.Content = lstControls;
return(controls);
}
public static List <Mapping> createNewMappings(TSF.UmlToolingFramework.Wrappers.EA.Attribute attribute, string basepath, ElementWrapper targetRootElement)
{
List <Mapping> returnedMappings = new List <Mapping>();
//connectors from owned attributes
foreach (ConnectorWrapper mappedConnector in attribute.relationships.OfType <ConnectorWrapper>())
{
if (!mappedConnector.taggedValues.Any(x => x.name == mappingSourcePathName && x.tagValue.ToString() != basepath))
{
//get the target base path
ConnectorMapping connectorMapping;
var targetTV = mappedConnector.taggedValues.FirstOrDefault(x => x.name == mappingTargetPathName);
string targetBasePath = string.Empty;
if (targetTV != null)
{
targetBasePath = targetTV.tagValue.ToString();
}
if (!string.IsNullOrEmpty(targetBasePath))
{
//connectorMapping = new ConnectorMapping(mappedConnector,basepath,targetBasePath);
}
else
{
//connectorMapping = new ConnectorMapping(mappedConnector,basepath,targetRootElement);
}
//returnedMappings.Add(connectorMapping);
}
}
//tagged value references from owned attributes
foreach (TaggedValue mappedTaggedValue in attribute.taggedValues.Where(x => x.tagValue is Element))
{
string mappingSourcePath = KeyValuePairsHelper.getValueForKey(mappingSourcePathName, mappedTaggedValue.comment);
string targetBasePath = KeyValuePairsHelper.getValueForKey(mappingTargetPathName, mappedTaggedValue.comment);
//if not filled in or corresponds to the attributeBasePath or the attributeBasePath + the name of the attribute
if (string.IsNullOrEmpty(mappingSourcePath) || mappingSourcePath == basepath ||
mappingSourcePath == basepath + "." + attribute.name)
{
TaggedValueMapping tagMapping;
if (!string.IsNullOrEmpty(targetBasePath))
{
//tagMapping = new TaggedValueMapping(mappedTaggedValue,basepath,targetBasePath);
}
else
{
//tagMapping = new TaggedValueMapping(mappedTaggedValue,basepath,targetRootElement);
}
//returnedMappings.Add(tagMapping);
}
}
//add the mappings for the type of the attribute
var attributeType = attribute.type as ElementWrapper;
if (attributeType != null)
{
returnedMappings.AddRange(createOwnedMappings(attributeType, basepath + "." + attribute.name, false));
}
return(returnedMappings);
}
