internal void RegisterComponents()
{
ComponentDefinition animationComponent = new ComponentDefinition("animation");
animationComponent.AddAttribute <string>("animationKeyframes");
ComponentRegistry.Instance.Register(animationComponent);
}
public void Initialize()
{
ComponentDefinition avatar = new ComponentDefinition("avatar");
avatar.AddAttribute <string>("userLogin", null);
ComponentRegistry.Instance.Register(avatar);
ClientManager.Instance.RegisterClientService("avatar", true, new Dictionary <string, Delegate> {
{ "getAvatarEntityGuid", (Func <Connection, string>)GetAvatarEntityGuid },
{ "changeAppearance", (Action <Connection, string, Vector>)ChangeAppearance },
{ "startAvatarMotionInDirection", (Action <Connection, Vector>)StartAvatarMotionInDirection },
{ "setAvatarForwardBackwardMotion", (Action <Connection, float>)SetForwardBackwardMotion },
{ "setAvatarLeftRightMotion", (Action <Connection, float>)SetLeftRightMotion },
{ "setAvatarSpinAroundAxis", (Action <Connection, Vector, float>)SetAvatarSpinAroundAxis }
});
ClientManager.Instance.NotifyWhenAnyClientAuthenticated(delegate(Connection connection) {
Activate(connection);
connection.Closed += (sender, e) => Deactivate(connection);
});
World.Instance.AddedEntity += HandleAddedEntity;
foreach (var entity in World.Instance)
{
CheckAndRegisterAvatarEntity(entity);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
//
//
//////////////////////////////////////////////////////////////////////////////////////////////
void InsertAsSurfaceGraphics(Matrix transfo)
{
Inventor.Application InvApp = AdnInventorUtilities.InvApplication;
Document document = InvApp.ActiveDocument;
ComponentDefinition compDef =
AdnInventorUtilities.GetCompDefinition(document);
_clientGraphicsMng.SetGraphicsSource(InvApp.ActiveDocument);
Dictionary <SurfaceBody, SurfaceBody> surfaceBodies =
AdnInventorUtilities.GetTransientBodies(
AdnInventorUtilities.GetCompDefinition(_componentDocument));
foreach (KeyValuePair <SurfaceBody, SurfaceBody> pair in surfaceBodies)
{
SurfaceGraphics surfGraph = _clientGraphicsMng.DrawSurface(pair.Value);
GraphicsNode node = surfGraph.Parent;
node.Transformation = transfo;
node.Selectable = true;
StyleSourceTypeEnum styleSourceType;
node.RenderStyle = pair.Key.GetRenderStyle(out styleSourceType);
}
}
public void InstantiateArrayPlacementRule()
{
Name = nameof(InstantiateArrayPlacementRule);
var red_cube = new Mass(
new Profile(Polygon.Rectangle(1, 1)),
1,
new Material("Red", new Color(1, 0, 0, 1)),
new Transform()
);
var green_cube = new Mass(
new Profile(Polygon.Rectangle(1, 1)),
7,
new Material("Green", new Color(0, 1, 0, 1)),
new Transform()
);
var blue_cube = new Mass(
new Profile(Polygon.Rectangle(1, 1)),
7,
new Material("Blue", new Color(0, 0, 1, 1)),
new Transform()
);
var refPath1 = new Polyline(new[] { new Vector3(1, 1), new Vector3(1, 19) });
var refPath2 = new Polyline(new[] { new Vector3(2, 18), new Vector3(18, 2) });
var refPath3 = new Polyline(new[] { new Vector3(19, 1), new Vector3(19, 19) });
var rule1 = ArrayPlacementRule.FromClosestPoints(red_cube, refPath1, new SpacingConfiguration(SpacingMode.ByCount, 5), TestReferencePointsA, "By Count Array");
var rule2 = ArrayPlacementRule.FromClosestPoints(green_cube, refPath2, new SpacingConfiguration(SpacingMode.ByApproximateLength, 4), TestReferencePointsA, "By Approx Length Array");
var rule3 = ArrayPlacementRule.FromClosestPoints(blue_cube, refPath3, new SpacingConfiguration(SpacingMode.ByLength, 2), TestReferencePointsA, "By Length Array");
// create a polyline rule, to visualize the boundary:
var boundaryRule = PolylinePlacementRule.FromClosestPoints(Polygon.Rectangle(new Vector3(0, 0, 0), new Vector3(20, 20)), TestReferencePointsA, "Boundary");
var definition = new ComponentDefinition(new IComponentPlacementRule[] { rule1, rule2, rule3, boundaryRule }, TestReferencePointsA);
ArrayResults(definition, TestTargetBoundariesA);
}
public void ReorderComponent(ComponentDefinition toMove, ComponentDefinition target, bool insertAtEnd, out int oldIndex, out int newIndex)
{
oldIndex = -1;
newIndex = -1;
int targetIndex = -1;
for (int i = 0; i < RootGroup.ComponentCount; i++)
{
var component = Components[RootGroup.GroupStartIndex + i];
if (component.Component == toMove)
{
oldIndex = i;
}
else if (component.Component == target)
{
targetIndex = i;
}
if (oldIndex != -1 && targetIndex != -1)
{
break;
}
}
if (oldIndex == -1 || targetIndex == -1)
{
var issue = oldIndex == -1 ? "" : "target";
Debug.LogError($"Could not find the {issue} component while reordering");
return;
}
newIndex = targetIndex + (insertAtEnd ? 1 : 0);
Components.Insert(newIndex, Components[oldIndex]);
Components.RemoveAt(oldIndex + (targetIndex < oldIndex ? 1 : 0));
}
public void InstantiateSizeBasedPlacementRule()
{
Name = nameof(InstantiateSizeBasedPlacementRule);
var sizes = new[] { 18, 15, 13, 10, 4 };
var elementConfigs = new List <(GeometricElement, Polygon)>();
var innerBoundary = Polygon.Rectangle(new Vector3(1, 1), new Vector3(19, 19));
foreach (var size in sizes)
{
var color = new Color(size / 18.0, 0, 1.0, 1.0);
var mat = new Material(size.ToString(), color);
var clearance = Polygon.Rectangle(new Vector3(0, 0), new Vector3(size, size));
var mass = new Mass(new Profile(clearance, clearance.Offset(-1), Guid.NewGuid(), null), 1, mat);
elementConfigs.Add((mass, clearance));
}
var rule = SizeBasedPlacementRule.FromClosestPoints(elementConfigs, innerBoundary, TestReferencePointsA, "Size rule");
// create a polyline rule, to visualize the boundary:
var boundaryRule1 = PolylinePlacementRule.FromClosestPoints(Polygon.Rectangle(new Vector3(0, 0, 0), new Vector3(20, 20)), TestReferencePointsA, "Boundary");
var boundaryRule2 = PolylinePlacementRule.FromClosestPoints(innerBoundary, TestReferencePointsA, "Boundary 2");
var definition = new ComponentDefinition(new IComponentPlacementRule[] { rule, boundaryRule1, boundaryRule2 }, TestReferencePointsA);
ArrayResults(definition, TestTargetBoundariesA);
}
public QueryComponent Find(ComponentDefinition componentDefinition, out QueryGroup owner)
{
owner = null;
var found = Components?.FirstOrDefault(x => x.Component == componentDefinition);
if (found != null)
{
QueryGroup FindGroup(QueryGroup targetGroup, QueryComponent component)
{
if (GetComponentsInQuery(targetGroup).Contains(component))
{
return(targetGroup);
}
foreach (var subGroup in GetSubGroups(targetGroup))
{
var inChildren = FindGroup(subGroup, component);
if (inChildren != null)
{
return(inChildren);
}
}
return(null);
}
owner = FindGroup(RootGroup, found);
}
return(found);
}
public void GetBomRowProperties(BOMRowsEnumerator rows, JArray bomRows)
{
const string TRACKING = "Design Tracking Properties";
foreach (BOMRow row in rows)
{
ComponentDefinition componentDef = row.ComponentDefinitions[1];
// Assumes not virtual component (if so add conditional for that here)
Property partNum = componentDef.Document.PropertySets[TRACKING]["Part Number"];
Property descr = componentDef.Document.PropertySets[TRACKING]["Description"];
Property material = componentDef.Document.PropertySets[TRACKING]["Material"];
JObject bomRow = new JObject(
new JProperty("row_number", row.ItemNumber),
new JProperty("part_number", partNum.Value),
new JProperty("quantity", row.ItemQuantity),
new JProperty("description", descr.Value),
new JProperty("material", material.Value)
);
// LogTrace("Add BOM Row #" + row.ItemNumber);
bomRows.Add(bomRow);
// iterate through child rows
if (row.ChildRows != null)
{
GetBomRowProperties(row.ChildRows, bomRows);
}
}
}
public override string GetOrDeclareComponentArray(
RoslynEcsTranslator.IterationContext ctx,
ComponentDefinition componentDefinition,
out LocalDeclarationStatementSyntax arrayInitialization,
out StatementSyntax arrayDisposal)
{
Type resolvedType = componentDefinition.TypeHandle.Resolve(m_Stencil);
var arrayName = ctx.GetComponentDataArrayName(resolvedType);
Type arrayType = typeof(NativeArray <>).MakeGenericType(resolvedType);
arrayInitialization = RoslynBuilder.DeclareLocalVariable(
arrayType, arrayName,
MakeInitComponentDataArrayExpression(ctx, resolvedType),
RoslynBuilder.VariableDeclarationType.InferredType);
arrayDisposal = ExpressionStatement(
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName(arrayName),
IdentifierName(nameof(IDisposable.Dispose)))))
.NormalizeWhitespace();
return(arrayName);
}
void DoDemo()
{
Inventor.Application InvApp = AdnInventorUtilities.InvApplication;
_compDef = AdnInventorUtilities.GetCompDefinition(InvApp.ActiveDocument);
_surfaceBodies = AdnInventorUtilities.GetTransientBodies(_compDef);
_interactionManager = new AdnInteractionManager(InvApp);
_interactionManager.Initialize();
_interactionManager.OnTerminateEvent +=
new AdnInteractionManager.OnTerminateHandler(OnTerminateEvent);
_clientGraphicsMng = new AdnClientGraphicsManager(
InvApp,
AdnInventorUtilities.AddInGuid);
_clientGraphicsMng.SetGraphicsSource(_interactionManager.InteractionEvents);
_interactionManager.SelectEvents.SingleSelectEnabled = true;
_interactionManager.AddSelectionFilter(SelectionFilterEnum.kPartFacePlanarFilter);
_interactionManager.AddSelectionFilter(SelectionFilterEnum.kWorkPlaneFilter);
_interactionManager.SelectEvents.OnSelect +=
new SelectEventsSink_OnSelectEventHandler(SelectEvents_OnSelect);
_interactionManager.Start("Select planar face or workplane: ");
}
private static ComponentInstance InstantiateLayout(SpaceConfiguration configs, double width, double length, Polygon rectangle, Transform xform)
{
ContentConfiguration selectedConfig = null;
var orderedKeys = configs.OrderByDescending(kvp => kvp.Value.CellBoundary.Depth * kvp.Value.CellBoundary.Width).Select(kvp => kvp.Key);
foreach (var key in orderedKeys)
{
var config = configs[key];
if (config.CellBoundary.Width < width && config.CellBoundary.Depth < length)
{
selectedConfig = config;
break;
}
}
if (selectedConfig == null)
{
return(null);
}
var baseRectangle = Polygon.Rectangle(selectedConfig.CellBoundary.Min, selectedConfig.CellBoundary.Max);
var rules = selectedConfig.Rules();
var componentDefinition = new ComponentDefinition(rules, selectedConfig.Anchors());
var instance = componentDefinition.Instantiate(ContentConfiguration.AnchorsFromRect(rectangle.TransformedPolygon(xform)));
var allPlacedInstances = instance.Instances;
foreach (var item in allPlacedInstances)
{
if (item is ElementInstance ei && !rectangle.Contains(ei.Transform.Origin))
{
}
}
return(instance);
}
public void ShouldStoreAndRetrieveComponent()
{
ComponentDefinition myComponent = new ComponentDefinition("myComponent");
myComponent.AddAttribute <int>("IntAttribute");
myComponent.AddAttribute <string>("StringAttribute");
componentRegistry.Register(myComponent);
if (plugin == null)
{
plugin = new PersistencePlugin();
plugin.Initialize();
}
Entity entity = new Entity();
World.Instance.Add(entity);
entity["myComponent"]["IntAttribute"] = 42;
entity["myComponent"]["StringAttribute"] = "Hello World!";
// De-Activate on-remove event handler, as for tests, we only want to remove the entity from the local registry, not from the
// persistence storage
World.Instance.RemovedEntity -= plugin.OnEntityRemoved;
World.Instance.Remove(entity);
plugin.RetrieveEntitiesFromDatabase();
Entity storedEntity = World.Instance.FindEntity(entity.Guid.ToString());
Assert.AreEqual(42, storedEntity["myComponent"]["IntAttribute"]);
Assert.AreEqual("Hello World!", storedEntity["myComponent"]["StringAttribute"]);
}
public void Setup() {
_c = new Container();
c1n = new ComponentDefinition<ITestService1, TestService1>(name: "test");
c1n2 = new ComponentDefinition<ITestService1, TestService1>(name: "test2");
c2nn = new ComponentDefinition<ITestService2, TestService2>(priority: 10);
c2n = new ComponentDefinition<ITestService2, TestService2>(name: "test");
}
void RegisterComponent()
{
ComponentDefinition avatar = new ComponentDefinition("avatar");
avatar.AddAttribute <string>("userLogin", null);
ComponentRegistry.Instance.Register(avatar);
}
public SheetParameters AddSheetParameters(ComponentDefinition cdef)
{
var parameters = SheetParameters.CreateViewsAuto(cdef, DrawDoc);
SheetsParameters.Add(parameters);
return(parameters);
}
public override string GetOrDeclareComponentArray(RoslynEcsTranslator.IterationContext ctx,
ComponentDefinition componentDefinition, out LocalDeclarationStatementSyntax arrayInitialization,
out StatementSyntax arrayDisposal)
{
var declaration = Parent.GetOrDeclareComponentArray(
ctx,
componentDefinition,
out arrayInitialization,
out arrayDisposal);
var parameter = declaration.ToCamelCase();
if (!(Parent is JobContext) || m_DeclaredComponentArray.Contains(componentDefinition))
{
return(parameter);
}
var componentType = componentDefinition.TypeHandle.Resolve(ctx.Stencil);
var arrayType = typeof(NativeArray <>).MakeGenericType(componentType);
m_Parameters.Add(
Argument(IdentifierName(declaration)),
Parameter(Identifier(parameter))
.WithType(TypeSystem.BuildTypeSyntax(arrayType)));
m_DeclaredComponentArray.Add(componentDefinition);
return(parameter);
}
void DefineComponents()
{
ComponentDefinition location = new ComponentDefinition("location");
location.AddAttribute<Vector>("position", new Vector(0, 0, 0));
location.AddAttribute<Quat>("orientation", new Quat(0, 0, 0, 1));
ComponentRegistry.Instance.Register(location);
}
public SheetParameters(ComponentDefinition cdef, DrawingDocument drawDoc)
{
Model = cdef.Document as _Document;
DrawDoc = drawDoc;
TitleBlocks = DrawDoc.TitleBlockDefinitions;
TitleBlock = null;
}
public static void RegisterComponent <TModel>(this ComponentRegistry componentRegistry)
where TModel : ComponentBase, new()
{
var type = typeof(TModel);
var instance = new TModel();
// TODO: this is gross
TypeDefinition GetProperties()
{
var method = type.GetMethod("GetModelAsync");
if (method != null)
{
// return type is Task<TModel>
var modelType = method.ReturnType.GenericTypeArguments.FirstOrDefault();
var builder = new TypeDefinitionBuilder(modelType, componentRegistry.PropertyMapper);
return(builder.Build());
}
return(null);
}
var definition = new ComponentDefinition
{
Alias = instance.Alias,
Control = type,
Placeholders = instance.Placeholders,
Properties = GetProperties()
};
componentRegistry.RegisterComponent(definition);
}
public void MockGlobalObjects()
{
handlers = new Mock <IHandlers>();
remoteConnectionMock = new Mock <Connection>();
remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "registerComponentDefinition"))
.Returns((ClientFunction)handlers.Object.RegisterComponentDefinition);
var remoteServerMock = new Mock <IRemoteServer>();
remoteServerMock.Setup(rs => rs.Connection).Returns(remoteConnectionMock.Object);
localServiceMock = new Mock <ServiceImplementation>();
var localServerMock = new Mock <ILocalServer>();
localServerMock.SetupGet(ls => ls.Service).Returns(localServiceMock.Object);
var serverSyncMock = new Mock <IServerSync>();
serverSyncMock.Setup(ss => ss.RemoteServers).Returns(new List <IRemoteServer> {
remoteServerMock.Object
});
serverSyncMock.Setup(ss => ss.LocalServer).Returns(localServerMock.Object);
componentRegistryMock = new Mock <IComponentRegistry>();
componentRegistryMock.SetupGet(cr => cr.RegisteredComponents).Returns(
new ReadOnlyCollection <ReadOnlyComponentDefinition>(new List <ReadOnlyComponentDefinition>()));
ServerSync.Instance = serverSyncMock.Object;
ComponentRegistry.Instance = componentRegistryMock.Object;
testComponentDefinition = new ComponentDefinition("test");
testComponentDefinition.AddAttribute <float>("f", 3.14f);
testComponentDefinition.AddAttribute <int>("i", 42);
}
/// <summary>
/// Registers gravity component that carries the attribute for the groundlevel
/// </summary>
internal void RegisterComponents()
{
ComponentDefinition gravityDefinition = new ComponentDefinition("avatarCollision");
gravityDefinition.AddAttribute <float>("groundLevel");
ComponentRegistry.Instance.Register(gravityDefinition);
}
void DefineComponents()
{
ComponentDefinition skeleton = new ComponentDefinition("skeleton");
skeleton.AddAttribute<List<Vector>>("translations", new List<Vector>());
skeleton.AddAttribute<List<Quat>>("rotations", new List<Quat>());
ComponentRegistry.Instance.Register(skeleton);
}
public void BomAccess()
{
AssemblyDocument oDoc = (AssemblyDocument)_InvApplication.ActiveDocument;
AssemblyComponentDefinition oDef = oDoc.ComponentDefinition;
BOM oBOM = default(BOM);
oBOM = oDef.BOM;
oBOM.StructuredViewEnabled = true;
BOMView oBomView = oBOM.BOMViews["Structured"];
int rowIdx = 0;
for (rowIdx = 1; rowIdx <= oBomView.BOMRows.Count; rowIdx++)
{
BOMRow oRow = oBomView.BOMRows[rowIdx];
Debug.Print("ItemNumber: " + oRow.ItemNumber + " TotalQuantity = " + oRow.TotalQuantity);
ComponentDefinition oCompDef = oRow.ComponentDefinitions[1];
PropertySet oDesignPropSet = default(PropertySet);
oDesignPropSet = oCompDef.Document.PropertySets("Design Tracking Properties");
}
}
/// <summary>
/// Register component that carries information about which model is used and what deviation
/// map should be displayed in the synchronized views
/// </summary>
private void RegisterComponent()
{
ComponentDefinition deviationMapComponent = new ComponentDefinition("deviationmap");
deviationMapComponent.AddAttribute<int>("selectedvector", 1);
deviationMapComponent.AddAttribute<float>("threshold", 1.5f);
ComponentRegistry.Instance.Register(deviationMapComponent);
}
private void GetBomRowProperties(BOMRowsEnumerator bomRowsEnumerator, List <object[]> rows)
{
foreach (BOMRow row in bomRowsEnumerator)
{
ComponentDefinition componentDef = row.ComponentDefinitions[1];
var trackingSet = componentDef.Document.PropertySets[TrackingProperties];
// Assumes not virtual component (if so add conditional for that here)
Property partNum = trackingSet["Part Number"];
Property description = trackingSet["Description"];
Property material = trackingSet["Material"];
object[] data = // order is important. a place to improve
{
row.ItemNumber,
partNum.Value,
row.ItemQuantity,
description.Value,
material.Value
};
rows.Add(data);
// iterate through child rows
if (row.ChildRows != null)
{
GetBomRowProperties(row.ChildRows, rows);
}
}
}
void DoDemo()
{
Inventor.Application InvApp = AdnInventorUtilities.InvApplication;
_compDef = AdnInventorUtilities.GetCompDefinition(InvApp.ActiveDocument);
_surfaceBodies = AdnInventorUtilities.GetTransientBodies(_compDef);
_interactionManager = new AdnInteractionManager(InvApp);
_interactionManager.Initialize();
_interactionManager.OnTerminateEvent +=
new AdnInteractionManager.OnTerminateHandler(OnTerminateEvent);
_clientGraphicsMng = new AdnClientGraphicsManager(
InvApp,
AdnInventorUtilities.AddInGuid);
_clientGraphicsMng.SetGraphicsSource(_interactionManager.InteractionEvents);
_interactionManager.SelectEvents.SingleSelectEnabled = true;
_interactionManager.AddSelectionFilter(SelectionFilterEnum.kPartFacePlanarFilter);
_interactionManager.AddSelectionFilter(SelectionFilterEnum.kWorkPlaneFilter);
_interactionManager.SelectEvents.OnSelect +=
new SelectEventsSink_OnSelectEventHandler(SelectEvents_OnSelect);
_interactionManager.Start("Select planar face or workplane: ");
}
private void ChooseComponent(object sender, RoutedEventArgs e)
{
SelectedComponent = (ComponentDefinition)((Button)sender).DataContext;
var flyout = this.GetParent <Flyout>();
flyout.IsOpen = false;
}
private static ComponentInstance InstantiateLayout(SpaceConfiguration configs, double width, double length, Polygon rectangle, Transform xform)
{
ContentConfiguration selectedConfig = null;
var orderedKeys = configs.OrderBy(k => rand.NextDouble()).Select(k => k.Key);
foreach (var key in orderedKeys)
{
var config = configs[key];
if (config.CellBoundary.Width < width && config.CellBoundary.Depth < length)
{
selectedConfig = config;
break;
}
}
if (selectedConfig == null)
{
return(null);
}
var baseRectangle = Polygon.Rectangle(selectedConfig.CellBoundary.Min, selectedConfig.CellBoundary.Max);
var rules = selectedConfig.Rules();
var componentDefinition = new ComponentDefinition(rules, selectedConfig.Anchors());
var instance = componentDefinition.Instantiate(ContentConfiguration.AnchorsFromRect(rectangle.TransformedPolygon(xform)));
return(instance);
}
//////////////////////////////////////////////////////////////////////////////////////////////
// Deletes all graphics (valid for parts and assembly documents only, and which doesn't
// contain ClientFeatures with graphics elements)
//
//////////////////////////////////////////////////////////////////////////////////////////////
public static void DeleteAllGraphics()
{
Inventor.Application InvApp = AdnInventorUtilities.InvApplication;
Document document = InvApp.ActiveDocument;
ClientGraphicsCollection cgCol = null;
GraphicsDataSetsCollection dataSetsCol = null;
switch (document.DocumentType)
{
case DocumentTypeEnum.kAssemblyDocumentObject:
case DocumentTypeEnum.kPartDocumentObject:
ComponentDefinition compDef =
AdnInventorUtilities.GetCompDefinition(document);
//Not a Part or Assembly, return
if (compDef == null)
{
return;
}
cgCol = compDef.ClientGraphicsCollection;
dataSetsCol = document.GraphicsDataSetsCollection;
break;
case DocumentTypeEnum.kDrawingDocumentObject:
DrawingDocument drawing = document as DrawingDocument;
cgCol = drawing.ActiveSheet.ClientGraphicsCollection;
dataSetsCol = drawing.ActiveSheet.GraphicsDataSetsCollection;
break;
default:
return;
}
if (cgCol.Count != 0)
{
foreach (ClientGraphics cg in cgCol)
{
cg.Delete();
}
}
if (dataSetsCol.Count != 0)
{
foreach (GraphicsDataSets dataSets in dataSetsCol)
{
dataSets.Delete();
}
}
InvApp.ActiveView.Update();
}
public ViewDefinition(ComponentDefinition component, string slot)
{
if (slot == null)
slot = string.Empty;
_component = component;
_slot = slot.ToLower();
}
void DefineComponents()
{
ComponentDefinition skeleton = new ComponentDefinition("skeleton");
skeleton.AddAttribute <List <Vector> >("translations", new List <Vector>());
skeleton.AddAttribute <List <Quat> >("rotations", new List <Quat>());
ComponentRegistry.Instance.Register(skeleton);
}
private void Action(ComponentDefinition cdef, int level)
{
if (!cdef.IsProjectPart())
{
return;
}
Writer.AddModel(cdef);
}
public bool TryGet(string name, out ComponentDefinition component)
{
component = _components.Value.FirstOrDefault(p => string.Equals(p.Name, name, StringComparison.InvariantCultureIgnoreCase));
if (component == null)
return false;
return true;
}
private void DefineComponents()
{
ComponentDefinition mesh = new ComponentDefinition("mesh");
mesh.AddAttribute<string>("uri");
mesh.AddAttribute<bool>("visible", true);
mesh.AddAttribute<Vector>("scale", new Vector(1, 1, 1));
ComponentRegistry.Instance.Register(mesh);
}
private void registerLightComponent()
{
ComponentDefinition lightComponent = new ComponentDefinition("light");
lightComponent.AddAttribute<LightType>("type");
lightComponent.AddAttribute<Vector>("intensity");
lightComponent.AddAttribute<Vector>("attenuation");
ComponentRegistry.Instance.Register(lightComponent);
}
public void Setup()
{
_c = new Container();
c1n = new ComponentDefinition <ITestService1, TestService1>(name: "test");
c1n2 = new ComponentDefinition <ITestService1, TestService1>(name: "test2");
c2nn = new ComponentDefinition <ITestService2, TestService2>(priority: 10);
c2n = new ComponentDefinition <ITestService2, TestService2>(name: "test");
}
void DefineComponents()
{
ComponentDefinition location = new ComponentDefinition("location");
location.AddAttribute <Vector>("position", new Vector(0, 0, 0));
location.AddAttribute <Quat>("orientation", new Quat(0, 0, 0, 1));
ComponentRegistry.Instance.Register(location);
}
private void RegisterNGSIComponent()
{
ComponentDefinition ngsi = new ComponentDefinition("ngsi");
ngsi.AddAttribute <string>("id");
ngsi.AddAttribute <string>("type");
ComponentRegistry.Instance.Register(ngsi);
}
internal void DefineComponents()
{
ComponentDefinition motion = new ComponentDefinition("motion");
motion.AddAttribute <Vector>("velocity", new Vector(0, 0, 0));
motion.AddAttribute <AxisAngle>("rotVelocity", new AxisAngle(0, 1, 0, 0));
ComponentRegistry.Instance.Register(motion);
}
public ModuleDefinition(string name, ComponentDefinition component)
{
if (string.IsNullOrWhiteSpace(name))
throw new ArgumentNullException("name");
if (component == null)
throw new ArgumentNullException("component");
Name = name;
Component = component;
}
private static void AddProperty(ComponentDefinition viewComponentDefinition, ViewDefinition view, string propertyName, object propertyValue)
{
var viewProperty = viewComponentDefinition.Type.GetProperty(propertyName);
if (viewProperty == null)
throw new XrcException(string.Format("Property '{0}' for type '{1}' not found.", propertyName, viewComponentDefinition.Type.FullName));
var propertyXValue = new XValue(viewProperty.PropertyType, propertyValue);
view.Properties.Add(new XProperty(viewProperty, propertyXValue));
}
/// <summary>
/// Initializes the plugin. This method will be called by the plugin manager when all dependency plugins have
/// been loaded.
/// </summary>
public void Initialize()
{
// Register 'scripting' component.
ComponentDefinition scripting = new ComponentDefinition("scripting");
scripting.AddAttribute<string>("ownerScript");
scripting.AddAttribute<string>("serverScript");
scripting.AddAttribute<string>("clientScript");
ComponentRegistry.Instance.Register(scripting);
Scripting.Instance = new Scripting();
}
internal void RegisterPersistedComponents()
{
foreach (KeyValuePair<string, ReadOnlyComponentDefinition> definitionPair in this.OwnerRegisteredComponents)
{
ReadOnlyComponentDefinition roDefinition = definitionPair.Value;
ComponentDefinition definition = new ComponentDefinition(roDefinition.Name);
foreach (ReadOnlyAttributeDefinition attrDef in definition.AttributeDefinitions)
definition.AddAttribute(attrDef.Name, attrDef.Type, attrDef.DefaultValue);
Registry.Register (definition);
}
}
public void Init()
{
// Set up definition.
definition = new ComponentDefinition("test-component");
definition.AddAttribute<string>("a", "a_value");
definition.AddAttribute<float>("b", 3.14f);
// Set up containing entity.
containingEntity = new Entity();
// Create component.
component = new Component(definition, containingEntity);
}
public void Init()
{
// TODO: mock ComponentDefinition
ComponentDefinition test = new ComponentDefinition("test");
test.AddAttribute<int>("a", 42);
test.AddAttribute<int?>("n", 5);
mockComponentRegistry = new Mock<IComponentRegistry>();
mockComponentRegistry.Setup(r => r.FindComponentDefinition("test")).Returns(test);
entity = new Entity();
entity.componentRegistry = mockComponentRegistry.Object;
mockHandlers = new Mock<IMockHandlers>();
}
public void It_should_position_http_headers()
{
var operation = new RemoraOperation {IncomingUri = new Uri(@"http://tempuri.org")};
var componentDefinition = new ComponentDefinition
{
Properties =
{
{"name", "foo"},
{"value", "bar"}
}
};
_setHttpHeader.BeginAsyncProcess(operation, componentDefinition, b =>
{
Assert.That(b);
Assert.That(!operation.OnError);
Assert.That(
operation.Request.HttpHeaders[
"foo"], Is.EqualTo("bar"));
});
}
public void It_should_throw_an_exception_if_name_or_value_not_in_component_definition()
{
var operation = new RemoraOperation {IncomingUri = new Uri(@"http://tempuri.org")};
var componentDefinition = new ComponentDefinition();
Assert.That(() => _setHttpHeader.BeginAsyncProcess(operation, componentDefinition, b => { }),
Throws.Exception.TypeOf<SetHttpHeaderException>()
.With.Message.Contains("name"));
componentDefinition.Properties["name"] = "foo";
Assert.That(() => _setHttpHeader.BeginAsyncProcess(operation, componentDefinition, b => { }),
Throws.Exception.TypeOf<SetHttpHeaderException>()
.With.Message.Contains("value"));
componentDefinition.Properties["name"] = "foo";
componentDefinition.Properties["value"] = "bar";
Assert.That(() => _setHttpHeader.BeginAsyncProcess(operation, componentDefinition, b => { }),
Throws.Nothing);
}
public void ShouldConvertCompatibleDefaultValues()
{
ComponentDefinition def = new ComponentDefinition("defTypeTest");
def.AddAttribute<double>("c", 42.0);
def.AddAttribute<int?>("e", null);
def.AddAttribute<int?>("f", 34);
Assert.Catch<AttributeDefinitionException>(delegate {
def.AddAttribute<double>("d", 42);
});
Assert.Catch<AttributeDefinitionException>(delegate {
def.AddAttribute<double>("a", 42);
});
Assert.Catch<AttributeDefinitionException>(delegate {
def.AddAttribute<double>("b", 42f);
});
Assert.Catch<AttributeDefinitionException>(delegate {
def.AddAttribute<int>("g", 3.14);
});
}
public void MockGlobalObjects()
{
handlers = new Mock<IHandlers>();
remoteConnectionMock = new Mock<Connection>();
remoteConnectionMock.Setup(rc => rc.GenerateClientFunction("serverSync", "registerComponentDefinition"))
.Returns((ClientFunction)handlers.Object.RegisterComponentDefinition);
var remoteServerMock = new Mock<IRemoteServer>();
remoteServerMock.Setup(rs => rs.Connection).Returns(remoteConnectionMock.Object);
localServiceMock = new Mock<ServiceImplementation>();
var localServerMock = new Mock<ILocalServer>();
localServerMock.SetupGet(ls => ls.Service).Returns(localServiceMock.Object);
var serverSyncMock = new Mock<IServerSync>();
serverSyncMock.Setup(ss => ss.RemoteServers).Returns(new List<IRemoteServer> { remoteServerMock.Object });
serverSyncMock.Setup(ss => ss.LocalServer).Returns(localServerMock.Object);
componentRegistryMock = new Mock<IComponentRegistry>();
componentRegistryMock.SetupGet(cr => cr.RegisteredComponents).Returns(
new ReadOnlyCollection<ReadOnlyComponentDefinition>(new List<ReadOnlyComponentDefinition>()));
ServerSync.Instance = serverSyncMock.Object;
ComponentRegistry.Instance = componentRegistryMock.Object;
testComponentDefinition = new ComponentDefinition("test");
testComponentDefinition.AddAttribute<float>("f", 3.14f);
testComponentDefinition.AddAttribute<int>("i", 42);
}
public RegisteredComponentEventArgs(ComponentDefinition definition)
{
ComponentDefinition = definition;
}
static void GetComponentsFromInputForRemove(ComAdminAppInfo appInfo, IList<ComponentDefinition<string>> inComps, out IList<ComponentDefinition<Guid>> outComps)
{
outComps = new List<ComponentDefinition<Guid>>();
foreach (ComponentDefinition<string> inComp in inComps)
{
ComponentDefinition<Guid> outComp = null;
ComAdminClassInfo classInfo = appInfo.FindClass(inComp.Component);
if (classInfo == null)
{
ToolConsole.WriteWarning(SR.GetString(SR.CannotFindComponentInApplicationSkipping, inComp.Component, Tool.Options.ShowGuids ? appInfo.ID.ToString("B") : appInfo.Name));
continue;
}
// Find existing componentDef if it was referenced in an earlier iteration
foreach (ComponentDefinition<Guid> cd in outComps)
{
if (cd.Component == classInfo.Clsid)
{
outComp = cd;
}
}
if (outComp == null)
{
outComp = new ComponentDefinition<Guid>(classInfo.Clsid);
}
if (inComp.AllInterfaces)
{
foreach (ComAdminInterfaceInfo interfaceInfo in classInfo.Interfaces)
outComp.AddInterface(interfaceInfo.Iid, ComPlusTypeValidator.FetchAllMethodsForInterface(interfaceInfo, false));
outComp.AddInterface(typeof(IMetadataExchange).GUID, null);
}
else
{
foreach (InterfaceDefination<string> comInterface in inComp.Interfaces)
{
string itfName = comInterface.Interface;
if (itfName == typeof(IMetadataExchange).GUID.ToString("B"))
{
outComp.AddInterface(typeof(IMetadataExchange).GUID, null);
}
else
{
ComAdminInterfaceInfo interfaceInfo = classInfo.FindInterface(itfName);
if (interfaceInfo == null)
{
ToolConsole.WriteWarning(SR.GetString(SR.CannotFindInterfaceInCatalogForComponentSkipping, itfName, inComp.Component));
continue;
}
if (comInterface.AllMethods)
{
outComp.AddInterface(interfaceInfo.Iid, ComPlusTypeValidator.FetchAllMethodsForInterface(interfaceInfo));
}
else
{
outComp.AddInterface(interfaceInfo.Iid, (List<string>)comInterface.Methods);
}
}
}
}
if (outComp.Interfaces != null)
outComps.Add(outComp);
else
{
ToolConsole.WriteWarning(SR.GetString(SR.NoneOfTheSpecifiedInterfacesForComponentWereFoundSkipping, inComp.Component));
}
}
}
public void Init()
{
definition = new ComponentDefinition("test-name");
}
void RegisterComponent()
{
ComponentDefinition avatar = new ComponentDefinition("avatar");
avatar.AddAttribute<string>("userLogin", null);
ComponentRegistry.Instance.Register(avatar);
}
public void Init()
{
registry = new ComponentRegistry();
definition = new ComponentDefinition("test2");
definition.AddAttribute<int>("a", 42);
}
//////////////////////////////////////////////////////////////////////////////////////
// Use: Draws a ComponentGraphics primitive
//
//////////////////////////////////////////////////////////////////////////////////////
public ComponentGraphics DrawComponent(
ComponentDefinition compDef)
{
return DrawComponent(compDef, null);
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Use: Returns a collection of transient bodies transformed in the context of the assembly
// (if compDef is an assembly CompDef).
// The Key of the dictionary is the original body, the value is the transformed transient body
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static Dictionary<SurfaceBody, SurfaceBody> GetTransientBodies(ComponentDefinition compDef)
{
Dictionary<SurfaceBody, SurfaceBody> bodies = new Dictionary<SurfaceBody, SurfaceBody>();
if (compDef.Type == ObjectTypeEnum.kAssemblyComponentDefinitionObject)
{
foreach (ComponentOccurrence occurrence in compDef.Occurrences)
{
if (occurrence.DefinitionDocumentType == DocumentTypeEnum.kAssemblyDocumentObject)
{
Dictionary<SurfaceBody, SurfaceBody> bodiesRec =
GetTransientBodies(occurrence.Definition);
foreach (SurfaceBody key in bodiesRec.Keys)
{
SurfaceBody bodyCpy = AdnInventorUtilities.InvApplication.TransientBRep.Copy(bodiesRec[key]);
AdnInventorUtilities.InvApplication.TransientBRep.Transform(
bodyCpy,
occurrence.Transformation);
bodies.Add(key, bodyCpy);
}
}
else
{
foreach (SurfaceBody body in occurrence.SurfaceBodies)
{
SurfaceBody bodyCpy = AdnInventorUtilities.InvApplication.TransientBRep.Copy(body);
AdnInventorUtilities.InvApplication.TransientBRep.Transform(
bodyCpy,
occurrence.Transformation);
bodies.Add(body, bodyCpy);
}
}
}
}
else
{
foreach (SurfaceBody body in compDef.SurfaceBodies)
{
SurfaceBody bodyCpy =
AdnInventorUtilities.InvApplication.TransientBRep.Copy(body);
bodies.Add(body, bodyCpy);
}
}
return bodies;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Use: Create a new derived PartDocument from a ComponentDefinition (asm or part)
//
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static PartDocument DeriveComponent(ComponentDefinition compDef)
{
Inventor.Application InvApp = AdnInventorUtilities.InvApplication;
PartDocument derivedDoc = InvApp.Documents.Add(
DocumentTypeEnum.kPartDocumentObject,
InvApp.FileManager.GetTemplateFile(DocumentTypeEnum.kPartDocumentObject,
SystemOfMeasureEnum.kDefaultSystemOfMeasure,
DraftingStandardEnum.kDefault_DraftingStandard,
null),
false) as PartDocument;
if (compDef.Type == ObjectTypeEnum.kAssemblyComponentDefinitionObject)
{
DerivedAssemblyComponents derAsmComps =
derivedDoc.ComponentDefinition.ReferenceComponents.DerivedAssemblyComponents;
DerivedAssemblyDefinition derAsmDef = derAsmComps.CreateDefinition(
(compDef.Document as Document).FullFileName);
derAsmDef.InclusionOption = DerivedComponentOptionEnum.kDerivedIncludeAll;
derAsmComps.Add(derAsmDef);
return derivedDoc;
}
if (compDef.Type == ObjectTypeEnum.kPartComponentDefinitionObject)
{
DerivedPartComponents derPartComps =
derivedDoc.ComponentDefinition.ReferenceComponents.DerivedPartComponents;
DerivedPartUniformScaleDef derPartDef = derPartComps.CreateDefinition(
(compDef.Document as Document).FullFileName);
derPartDef.IncludeAll();
derPartComps.Add(derPartDef as DerivedPartDefinition);
return derivedDoc;
}
derivedDoc.Close(true);
return null;
}
// returns strongly typed, verified components, from loosely-typed (string) user inputs
static void GetComponentsFromInputForAdd(ComAdminAppInfo appInfo, IList<ComponentDefinition<string>> inComps, bool mex, bool priorEndpointsExist, out IList<ComponentDefinition<Guid>> outComps)
{
string missingInterface = String.Empty;
outComps = new List<ComponentDefinition<Guid>>();
foreach (ComponentDefinition<string> inComp in inComps)
{
ComponentDefinition<Guid> outComp = null;
ComAdminClassInfo classInfo = appInfo.FindClass(inComp.Component);
if (classInfo == null)
{
ToolConsole.WriteWarning(SR.GetString(SR.CannotFindComponentInApplicationSkipping, inComp.Component, Tool.Options.ShowGuids ? appInfo.ID.ToString("B") : appInfo.Name));
continue;
}
if (!ValidateClass(classInfo))
continue;
// Find existing componentDef if it was referenced in an earlier iteration
foreach (ComponentDefinition<Guid> cd in outComps)
{
if (cd.Component == classInfo.Clsid)
{
outComp = cd;
}
}
if (outComp == null)
{
outComp = new ComponentDefinition<Guid>(classInfo.Clsid);
}
if (inComp.AllInterfaces)
{
foreach (ComAdminInterfaceInfo interfaceInfo in classInfo.Interfaces)
{
if (ComPlusTypeValidator.VerifyInterface(interfaceInfo, options.AllowReferences, classInfo.Clsid))
outComp.AddInterface(interfaceInfo.Iid, ComPlusTypeValidator.FetchAllMethodsForInterface(interfaceInfo));
}
if ((outComp.Interfaces != null) && mex)
outComp.AddInterface(typeof(IMetadataExchange).GUID, null);
}
else
{
foreach (InterfaceDefination<string> comInterface in inComp.Interfaces)
{
string itfName = comInterface.Interface;
if (itfName == typeof(IMetadataExchange).GUID.ToString("B"))
{
if (!mex)
outComp.AddInterface(typeof(IMetadataExchange).GUID, null);
}
else
{
ComAdminInterfaceInfo interfaceInfo = classInfo.FindInterface(itfName);
if (interfaceInfo == null)
{
ToolConsole.WriteWarning(SR.GetString(SR.CannotFindInterfaceInCatalogForComponentSkipping, itfName, inComp.Component));
missingInterface = itfName;
continue;
}
if (comInterface.AllMethods)
{
if (ComPlusTypeValidator.VerifyInterface(interfaceInfo, options.AllowReferences, classInfo.Clsid, true))
outComp.AddInterface(interfaceInfo.Iid, ComPlusTypeValidator.FetchAllMethodsForInterface(interfaceInfo));
else
throw CreateException(SR.GetString(SR.InvalidInterface), null);
}
else
{
if (ComPlusTypeValidator.VerifyInterfaceMethods(interfaceInfo, comInterface.Methods, options.AllowReferences, true))
outComp.AddInterface(interfaceInfo.Iid, (List<string>)comInterface.Methods);
else
throw CreateException(SR.GetString(SR.InvalidMethod), null);
}
}
}
if ((outComp.Interfaces != null) || priorEndpointsExist)
{
if (mex)
outComp.AddInterface(typeof(IMetadataExchange).GUID, null);
}
}
if (outComp.Interfaces != null)
outComps.Add(outComp);
else
ToolConsole.WriteWarning(SR.GetString(SR.NoneOfTheSpecifiedInterfacesForComponentWereFoundSkipping, inComp.Component));
}
if (outComps.Count == 0 && (!String.IsNullOrEmpty(missingInterface)))
throw Tool.CreateException(SR.GetString(SR.NoComponentContainsInterface, missingInterface), null);
}
public ComponentGraphics DrawComponent(
ComponentDefinition compDef,
GraphicsNode node)
{
try
{
AdnGraphics graphicsData = WorkingGraphics;
if (node == null)
{
node = graphicsData.ClientGraphics.AddNode(
graphicsData.GetGraphicNodeFreeId());
}
ComponentGraphics graphic = node.AddComponentGraphics(compDef);
return graphic;
}
catch
{
return null;
}
}
public object Get(ComponentDefinition component, IContext context = null)
{
return _windsorKernel.Resolve(component.Type, new { context = context });
}
