/// <summary>
/// Creates a new <see cref="FactType"/> with the specified <paramref name="arity"/>.
/// </summary>
/// <param name="store">
/// The <see cref="Store"/> in which the new <see cref="FactType"/> should be created.
/// </param>
/// <param name="group">
/// The <see cref="ElementGroup"/> to which the new <see cref="FactType"/> and its <see cref="Role"/>s should
/// be added.
/// </param>
/// <param name="arity">
/// The number of <see cref="Role"/>s that the new <see cref="FactType"/> should contain.
/// </param>
/// <returns>
/// The newly created <see cref="FactType"/>.
/// </returns>
/// <remarks>
/// The new <see cref="FactType"/> is added to <paramref name="group"/> as a root element.
/// </remarks>
private static FactType AddFactType(Store store, ElementGroup group, int arity)
{
FactType factType = new FactType(store, null);
group.AddGraph(factType, true);
LinkedElementCollection <RoleBase> roles = factType.RoleCollection;
for (int i = 0; i < arity; i++)
{
Role role = new Role(store);
roles.Add(role);
group.AddGraph(role);
}
return(factType);
}
private static ElementGroupPrototype MakePrototype(GadgeteerHardware element)
{
var elementGroup = new ElementGroup(element.Store.DefaultPartition);
elementGroup.AddGraph(element, true);
return(elementGroup.CreatePrototype());
}
/* There are two versions of CreateElementToolPrototype here.
* One deals with each Component subtype separately: if you add a new subtype, you need to add more here.
* The other automatically deals with eacn Component subtype, using DSL reflection info.
*
* See http://msdn.microsoft.com/library/bb126279.aspx#groups
*/
/*
* /// <summary>
* /// Toolbox initialization, called for each element tool on the toolbox.
* /// This version deals with each Component subtype separately.
* /// </summary>
* /// <param name="store"></param>
* /// <param name="domainClassId">Identifies the domain class this tool should instantiate.</param>
* /// <returns>prototype of the object or group of objects to be created by tool</returns>
* protected override ElementGroupPrototype CreateElementToolPrototype(Store store, Guid domainClassId)
* {
*
* if (domainClassId == Resistor.DomainClassId)
* {
* Resistor resistor = new Resistor(store);
*
* // Must initialize these in order of initialization:
* // DSLT v1 bug affecting derived relationships.
* resistor.T1 = new ComponentTerminal(store);
* resistor.T2 = new ComponentTerminal(store);
*
* resistor.T1.Name = "t1";
* resistor.T2.Name = "t2";
*
* ElementGroup elementGroup = new ElementGroup(store.DefaultPartition);
* elementGroup.AddGraph(resistor, true);
* // AddGraph includes the embedded parts.
*
* return elementGroup.CreatePrototype();
* }
* else if (domainClassId == Capacitor.DomainClassId)
* {
* Capacitor capacitor = new Capacitor(store);
*
* // Must initialize these in order of initialization:
* // DSLT v1 bug affecting derived relationships.
* capacitor.T1 = new ComponentTerminal(store);
* capacitor.T2 = new ComponentTerminal(store);
*
* capacitor.T1.Name = "t1";
* capacitor.T2.Name = "t2";
*
* ElementGroup elementGroup = new ElementGroup(store.DefaultPartition);
* elementGroup.AddGraph(capacitor, true);
* // AddGraph includes the embedded parts.
*
* return elementGroup.CreatePrototype();
* }
*
* else if (domainClassId == Transistor.DomainClassId)
* {
* Transistor transistor = new Transistor(store);
*
* // Must initialize these in order of initialization:
* // DSLT v1 bug affecting derived relationships.
* transistor.Base = new ComponentTerminal(store);
* transistor.Collector = new ComponentTerminal(store);
* transistor.Emitter = new ComponentTerminal(store);
*
* transistor.Base.Name = "base";
* transistor.Collector.Name = "collector";
* transistor.Emitter.Name = "emitter";
*
* // Create an ElementGroup for the Toolbox.
* ElementGroup elementGroup = new ElementGroup(store.DefaultPartition);
* elementGroup.AddGraph(transistor, true);
* // AddGraph includes the embedded parts
*
* return elementGroup.CreatePrototype();
* }
*
* else
* {
* return base.CreateElementToolPrototype(store, domainClassId);
* }
*
*
* }
*
*/
/// <summary>
/// Toolbox initialization for components with fixed embedded parts.
/// This deals with all the subclasses of Component, adding an instance for each relationship derived from ComponentHasTerminals.
/// The benefit of this approach is that it does not need to be adjusted for each new Component subclass.
/// Called for each element tool on the toolbox.
/// </summary>
/// <param name="store"></param>
/// <param name="domainClassId">Identifies the domain class this tool should instantiate.</param>
/// <returns>prototype of the object or group of objects to be created by tool</returns>
protected override ElementGroupPrototype CreateElementToolPrototype(Store store, Guid domainClassId)
{
// Called for each element tool on the toolbox.
// Get the class meta info for this class.
DomainClassInfo thisClassInfo = store.DomainDataDirectory.FindDomainClass(domainClassId);
if (!thisClassInfo.IsDerivedFrom(Component.DomainClassId))
{
// Not one of those we're interested in: defer to base method.
return(base.CreateElementToolPrototype(store, domainClassId));
}
else
{
// Construct an instance of this type. Use the constructor that takes a store and a variable number of property bindings.
Component component = (Component)thisClassInfo.ImplementationClass. // get the actual class from the meta info
InvokeMember( // method in System.Reflection.Type
"",
System.Reflection.BindingFlags.CreateInstance // invoke the constructor
| System.Reflection.BindingFlags.OptionalParamBinding, // which has a params binding
null, // no special binder
null, //no target object since we want the constructor
new object[] { store }); // Called like "new Resistor(store)"
// Now add whatever ComponentTerminals it has.
// Each Component subtype sources several subrelationships of ComponentHasComponentTerminal.
// Go through the metainfo about each role the class plays in relationships.
foreach (DomainRoleInfo role in thisClassInfo.LocalDomainRolesPlayed)
{
// Pick out the roles that are one end of a relationship to a Terminal.
if (role.DomainRelationship.IsDerivedFrom(ComponentHasComponentTerminal.DomainClassId) &&
!role.DomainRelationship.ImplementationClass.IsAbstract)
{
ComponentTerminal terminal = new ComponentTerminal(store);
// Fill in the instance name with the name of the role - just a convenience.
// The role at the Terminal end of the relationship is the one called "T1" or "collector" or some such.
terminal.Name = role.OppositeDomainRole.Name.ToLowerInvariant();
// Instantiate the relationship with the constructor that takes the component and terminal.
role.DomainRelationship.ImplementationClass.InvokeMember("", System.Reflection.BindingFlags.CreateInstance,
null, null,
new object[] { component, terminal });
}
}
// Create an Element Group Prototype containing this tree.
ElementGroup elementGroup = new ElementGroup(store.DefaultPartition);
elementGroup.AddGraph(component, true, true); // AddGraph includes the embedded elements.
elementGroup.AddRange(component.ComponentTerminals, true);
ElementGroupPrototype egp = elementGroup.CreatePrototype();
return(egp);
}
}
/// <summary>
/// Create a serialized prototype for Activity to attach to the toolbox.
/// </summary>
/// <param name="toolboxItem"></param>
/// <returns>The prototype</returns>
public override ElementGroupPrototype InitializeToolboxItem(ModelingToolboxItem toolboxItem)
{
ElementGroup elementGroup = new ElementGroup(this.Store);
ElementGroupPrototype proto = null;
Debug.Assert(this.Store.TransactionManager.InTransaction, "Must be in transaction");
ISpySoft.SFSchemaLanguage.DomainModel.Activity instance = ISpySoft.SFSchemaLanguage.DomainModel.Activity.CreateActivity(this.Store);
if (instance != null)
{
elementGroup.AddGraph(instance);
proto = elementGroup.CreatePrototype(instance);
}
return(proto);
}
/// <summary>
/// Execute the command
/// </summary>
public void Exec()
{
ElementGroup elementGroup = new ElementGroup(_store);
bool foundSome = false;
foreach (object o in _elements)
{
// Pick out shapes representing Component model elements.
ShapeElement element = o as ShapeElement;
if (element != null && element.ModelElement != null || o is ModelElement)
{
ModelElement mel = element != null ? element.ModelElement : o as ModelElement;
if (mel is Entity ||
mel is Operation ||
mel is Enumeration ||
mel is ClassImplementation ||
mel is ServiceContract ||
mel is Property)
{
// add the element and its embedded children to the group
elementGroup.AddGraph(mel, true);
foundSome = true;
}
}
}
if (!foundSome)
{
return;
}
// A DataObject carries a serialized version.
System.Windows.Forms.IDataObject data = new System.Windows.Forms.DataObject();
data.SetData(elementGroup.CreatePrototype());
System.Windows.Forms.Clipboard.SetDataObject
(data, // serialized clones of our selected model elements
false, // we don’t want to export outside this application
10, // retry 10 times on failure
50); // waiting 50ms between retries
}
/// <summary>See <see cref="ORMShapeToolboxHelperBase.CreateElementToolPrototype"/>.</summary>
protected sealed override ElementGroupPrototype CreateElementToolPrototype(Store store, Guid domainClassId)
{
// WARNING: This method is _extremely_ order-sensitive. If the order that the toolbox items are listed
// in the .dsl file changes, or if the DSL Tools text template that is used to generate ORMShapeModelToolboxHelperBase
// changes, this method will most likely need to be changed as well.
ElementGroup group = null;
bool unknownItem = false;
if (domainClassId.Equals(ObjectType.DomainClassId))
{
group = new ElementGroup(store);
ObjectType objectType = new ObjectType(store);
group.AddGraph(objectType, true);
switch (myObjectTypeCount++)
{
case 0:
// EntityType - We don't need to do anything else...
break;
case 1:
// ValueType
// Do not try to set the IsValueType property here. IsValueType picks
// up the default data type for the model, which can only be done
// when the model is known. Instead, flag the element so that it
// can be set during MergeRelate on the model.
group.UserData = ORMModel.ValueTypeUserDataKey;
break;
case 2:
// ObjectifiedFactType
group.AddGraph(new Objectification(objectType, AddFactType(store, group, 2)), false);
break;
default:
unknownItem = true;
break;
}
}
else if (domainClassId.Equals(FactType.DomainClassId))
{
group = new ElementGroup(store);
Debug.Assert(myFactTypeCount < 3);
AddFactType(store, group, ++myFactTypeCount);
}
else if (domainClassId.Equals(ExclusiveOrConstraintCoupler.DomainClassId))
{
group = new ElementGroup(store);
MandatoryConstraint mandatory = new MandatoryConstraint(store, null);
group.AddGraph(mandatory, true);
ExclusionConstraint exclusion = new ExclusionConstraint(store, null);
group.AddGraph(exclusion, true);
group.AddGraph(new ExclusiveOrConstraintCoupler(mandatory, exclusion), false);
}
else if (domainClassId.Equals(UniquenessConstraint.DomainClassId))
{
group = new ElementGroup(store);
if (myUniquenessConstraintCount == 0)
{
// Add this here so that we can distinguish between internal and external uniqueness
// constraints without unpacking the model. We want to merge internals into a fact
// and externals into the model.
group.UserData = ORMModel.InternalUniquenessConstraintUserDataKey;
group.AddGraph(UniquenessConstraint.CreateInternalUniquenessConstraint(store.DefaultPartition), true);
}
else
{
Debug.Assert(myUniquenessConstraintCount == 1);
group.AddGraph(new UniquenessConstraint(store), true);
}
myUniquenessConstraintCount++;
}
return((group == null || unknownItem) ? base.CreateElementToolPrototype(store, domainClassId) : group.CreatePrototype());
}
/// <summary>See <see cref="ORMShapeToolboxHelperBase.CreateElementToolPrototype"/>.</summary>
protected sealed override ElementGroupPrototype CreateElementToolPrototype(Store store, Guid domainClassId)
{
// WARNING: This method is _extremely_ order-sensitive. If the order that the toolbox items are listed
// in the .dsl file changes, or if the DSL Tools text template that is used to generate ORMShapeModelToolboxHelperBase
// changes, this method will most likely need to be changed as well.
ElementGroup group = null;
bool unknownItem = false;
if (domainClassId.Equals(ObjectType.DomainClassId))
{
group = new ElementGroup(store);
ObjectType objectType = new ObjectType(store);
group.AddGraph(objectType, true);
switch (myObjectTypeCount++)
{
case 0:
// EntityType - We don't need to do anything else...
break;
case 1:
// ValueType
// Do not try to set the IsValueType property here. IsValueType picks
// up the default data type for the model, which can only be done
// when the model is known. Instead, flag the element so that it
// can be set during MergeRelate on the model.
group.UserData = ORMModel.ValueTypeUserDataKey;
break;
case 2:
// ObjectifiedFactType
group.AddGraph(new Objectification(objectType, AddFactType(store, group, 2)), false);
break;
default:
unknownItem = true;
break;
}
}
else if (domainClassId.Equals(FactType.DomainClassId))
{
group = new ElementGroup(store);
Debug.Assert(myFactTypeCount < 3);
AddFactType(store, group, ++myFactTypeCount);
}
else if (domainClassId.Equals(ExclusiveOrConstraintCoupler.DomainClassId))
{
group = new ElementGroup(store);
MandatoryConstraint mandatory = new MandatoryConstraint(store, null);
group.AddGraph(mandatory, true);
ExclusionConstraint exclusion = new ExclusionConstraint(store, null);
group.AddGraph(exclusion, true);
group.AddGraph(new ExclusiveOrConstraintCoupler(mandatory, exclusion), false);
}
else if (domainClassId.Equals(UniquenessConstraint.DomainClassId))
{
group = new ElementGroup(store);
if (myUniquenessConstraintCount == 0)
{
// Add this here so that we can distinguish between internal and external uniqueness
// constraints without unpacking the model. We want to merge internals into a fact
// and externals into the model.
group.UserData = ORMModel.InternalUniquenessConstraintUserDataKey;
group.AddGraph(UniquenessConstraint.CreateInternalUniquenessConstraint(store), true);
}
else
{
Debug.Assert(myUniquenessConstraintCount == 1);
group.AddGraph(new UniquenessConstraint(store), true);
}
myUniquenessConstraintCount++;
}
return (group == null || unknownItem) ? base.CreateElementToolPrototype(store, domainClassId) : group.CreatePrototype();
}
/// <summary>
/// Creates a new <see cref="FactType"/> with the specified <paramref name="arity"/>.
/// </summary>
/// <param name="store">
/// The <see cref="Store"/> in which the new <see cref="FactType"/> should be created.
/// </param>
/// <param name="group">
/// The <see cref="ElementGroup"/> to which the new <see cref="FactType"/> and its <see cref="Role"/>s should
/// be added.
/// </param>
/// <param name="arity">
/// The number of <see cref="Role"/>s that the new <see cref="FactType"/> should contain.
/// </param>
/// <returns>
/// The newly created <see cref="FactType"/>.
/// </returns>
/// <remarks>
/// The new <see cref="FactType"/> is added to <paramref name="group"/> as a root element.
/// </remarks>
private static FactType AddFactType(Store store, ElementGroup group, int arity)
{
FactType factType = new FactType(store, null);
group.AddGraph(factType, true);
LinkedElementCollection<RoleBase> roles = factType.RoleCollection;
for (int i = 0; i < arity; i++)
{
Role role = new Role(store);
roles.Add(role);
group.AddGraph(role);
}
return factType;
}
