private bool PasteShapes() { // Get prototypes from clipboard, if they exist IDataObject dataObject = Clipboard.GetDataObject(); ElementGroupPrototype elementGroupPrototype = ElementOperations.GetElementGroupPrototype(ServiceProvider, dataObject); // if we're not pasting on the diagram (i.e., the ModelRoot), we're pasting the prototype if (TargetElement is ModelRoot && CurrentModelingDocView is EFModelDocView efModelDocView && efModelDocView.Diagram is EFModelDiagram currentDiagram && currentDiagram?.Store != null && elementGroupPrototype != null) { Store store = efModelDocView.Diagram.Store; // get matching elements from the store List <ModelElement> modelElements = elementGroupPrototype.ProtoElements .Select(p => store.ElementDirectory.FindElement(p.ElementId)) .Where(e => e != null) .ToList(); if (modelElements.Any()) { List <ModelClass> modelClasses = modelElements.OfType <ModelClass>().ToList(); List <Comment> comments = modelElements.OfType <Comment>().ToList(); List <ModelElement> everythingElse = modelElements.Except(modelClasses).Except(comments).ToList(); List <ShapeElement> newShapes = new List <ShapeElement>(); using (Transaction t = store.TransactionManager.BeginTransaction()) { // paste classes and comments first to ensure that any possible connector end is present before the connectors arrive newShapes.AddRange(modelClasses.Select(e => EFModelDiagram.AddExistingModelElement(currentDiagram, e))); newShapes.AddRange(comments.Select(e => EFModelDiagram.AddExistingModelElement(currentDiagram, e))); newShapes.AddRange(everythingElse.Select(e => EFModelDiagram.AddExistingModelElement(currentDiagram, e))); newShapes = newShapes.Where(s => s != null).ToList(); // if nothing got pasted (because it's already there), we succeeded in our paste but didn't really change // the display, so nothing further needs done if (!newShapes.Any()) { return(true); } t.Commit(); } using (Transaction t = store.TransactionManager.BeginTransaction()) { Commands.LayoutDiagram(currentDiagram, newShapes); t.Commit(); } currentDiagram.Invalidate(); return(true); } } return(false); }
/// <summary> /// Returns a value indicating whether the source element represented by the /// specified root ProtoElement can be added to this element. /// </summary> /// <param name="rootElement">The root ProtoElement representing a source element. This can be null, /// in which case the ElementGroupPrototype does not contain an ProtoElements /// and the code should inspect the ElementGroupPrototype context information.</param> /// <param name="elementGroupPrototype">The ElementGroupPrototype that contains the root ProtoElement.</param> /// <returns> /// True if the source element represented by the ProtoElement can be added to this target element. /// </returns> protected override bool CanMerge(ProtoElementBase rootElement, ElementGroupPrototype elementGroupPrototype) { Guard.NotNull(() => rootElement, rootElement); Guard.NotNull(() => elementGroupPrototype, elementGroupPrototype); return false; }
private ModelingToolboxItem CreateToolboxItem(Store store, GadgeteerPart moduleDefinition, string description, string tabName, ElementGroupPrototype prototype, string itemId) { //Add a filter attribute for each of the .NETMF versions supported by this module. The DocData adds a corresponding //filter depending on the version of the project var filters = moduleDefinition.SupportedMicroframeworkVersions.Select(v => new ToolboxItemFilterAttribute(GadgeteerDSLToolboxHelperBase.ToolboxFilterString + v, ToolboxItemFilterType.Require)).ToArray(); var result = new ModelingToolboxItem( itemId, // Unique identifier (non-localized) for the toolbox item. 2, // Position relative to other items in the same toolbox tab. moduleDefinition.Name, moduleToolboxIcon, // Image displayed next to the toolbox item. "Microsoft.Gadgeteer.Designer.GadgeteerDSLToolboxTab", // Unique identifier (non-localized) for the toolbox item tab. tabName, // Localized display name for the toolbox tab. moduleDefinition.Name, // F1 help keyword for the toolbox item. description, // Localized tooltip text for the toolbox item. prototype, filters ); //Imporant to make this transient. Otherwise the toolbox items remain even if modules are uninstalled result.IsTransient = true; return(result); }
private static T CreateChildElement <T>(ModelElement parent, bool raiseInstantiateEvents) where T : ModelElement { var childClass = parent.Partition.DomainDataDirectory.DomainClasses .FirstOrDefault(dci => typeof(T).IsAssignableFrom(dci.ImplementationClass) && !dci.ImplementationClass.IsAbstract); var elementOperations = new ElementOperations(parent.Store, parent.Partition); if (elementOperations != null) { var elementGroupPrototype = new ElementGroupPrototype(parent.Partition, childClass.Id); var partition = elementOperations.ChooseMergeTarget(parent, elementGroupPrototype).Partition; var element = (T)partition.ElementFactory.CreateElement(childClass); var elementGroup = new ElementGroup(partition); elementGroup.Add(element); elementGroup.MarkAsRoot(element); elementOperations.MergeElementGroup(parent, elementGroup); // Flag the element in the state so that the ProductStore class sees it and doesn't // raise the instantiation event. if (!raiseInstantiateEvents) { element.Store.PropertyBag.Add(element, null); } return(element); } return(default(T)); }
/// <summary> /// Returns a value indicating whether the source element represented by the /// specified root ProtoElement can be added to this element. /// </summary> /// <param name="rootElement">The root ProtoElement representing a source element. This can be null, /// in which case the ElementGroupPrototype does not contain an ProtoElements /// and the code should inspect the ElementGroupPrototype context information.</param> /// <param name="elementGroupPrototype">The ElementGroupPrototype that contains the root ProtoElement.</param> /// <returns> /// True if the source element represented by the ProtoElement can be added to this target element. /// </returns> protected override bool CanMerge(ProtoElementBase rootElement, ElementGroupPrototype elementGroupPrototype) { Guard.NotNull(() => rootElement, rootElement); Guard.NotNull(() => elementGroupPrototype, elementGroupPrototype); return(false); }
/// <summary> /// Determines whether this instance [can merge interface layer] the specified root element. /// </summary> /// <param name="rootElement">The root element.</param> /// <param name="elementGroupPrototype">The element group prototype.</param> /// <returns> /// <c>true</c> if this instance [can merge interface layer] the specified root element; otherwise, <c>false</c>. /// </returns> private bool CanMergeInterfaceLayer(ProtoElementBase rootElement, ElementGroupPrototype elementGroupPrototype) { if (elementGroupPrototype == null) { throw new ArgumentNullException("elementGroupPrototype"); } return(InterfaceLayer == null); }
protected override bool CanMerge(ProtoElementBase rootElement, ElementGroupPrototype elementGroupPrototype) { if (this.Parent != null) { // forward to parent return(this.Parent.internalCanMerge(this, rootElement, elementGroupPrototype)); } return(base.CanMerge(rootElement, elementGroupPrototype)); }
protected override bool CanMerge(ProtoElementBase rootElement, ElementGroupPrototype elementGroupPrototype) { if (this.Parent != null) { // forward to parent return this.Parent.internalCanMerge(this, rootElement, elementGroupPrototype); } return base.CanMerge(rootElement, elementGroupPrototype); }
protected override bool CanMerge(ProtoElementBase rootElement, ElementGroupPrototype elementGroupPrototype) { if (rootElement != null && rootElement.ElementId == Guid.Empty) { var rootElementDomainInfo = Partition.DomainDataDirectory.GetDomainClass(rootElement.DomainClassId); if (rootElementDomainInfo.IsDerivedFrom(NavigationProperty.DomainClassId)) { return(false); } } return(base.CanMerge(rootElement, elementGroupPrototype)); }
/* 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); } }
protected override bool CanMerge(ProtoElementBase rootElement, ElementGroupPrototype elementGroupPrototype) { if (rootElement != null && rootElement.ElementId == Guid.Empty) { var rootElementDomainInfo = Partition.DomainDataDirectory.GetDomainClass(rootElement.DomainClassId); if (rootElementDomainInfo.IsDerivedFrom(NavigationProperty.DomainClassId)) { return false; } } return base.CanMerge(rootElement, elementGroupPrototype); }
/// <summary> /// Check whether this model class is an acceptor for the content of a prototype /// </summary> /// <param name="elementGroupPrototype"></param> /// <param name="protoElement"></param> /// <returns></returns> protected override bool CanAddChildElement(ElementGroupPrototype elementGroupPrototype, ProtoElementBase protoElement) { if (protoElement != null) { bool canAdd = false; MetaClassInfo metaClassInfo = this.Store.MetaDataDirectory.FindMetaClass(protoElement.MetaClassId); if (typeof(ISpySoft.SFSchemaLanguage.DomainModel.SchemaModelItem).IsAssignableFrom(metaClassInfo.ImplementationClass)) { canAdd = true; } return(canAdd); } return(false); }
/// <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> /// Returns a value indicating whether the source element represented by the /// specified root ProtoElement can be added to this element. /// </summary> /// <param name="rootElement">The root ProtoElement representing a source element. This can be null, /// in which case the ElementGroupPrototype does not contain an ProtoElements /// and the code should inspect the ElementGroupPrototype context information.</param> /// <param name="elementGroupPrototype">The ElementGroupPrototype that contains the root ProtoElement.</param> /// <returns> /// True if the source element represented by the ProtoElement can be added to this target element. /// </returns> protected override bool CanMerge(ProtoElementBase rootElement, ElementGroupPrototype elementGroupPrototype) { Guard.NotNull(() => rootElement, rootElement); Guard.NotNull(() => elementGroupPrototype, elementGroupPrototype); if (rootElement != null) { var rootElementDomainInfo = this.Partition.DomainDataDirectory.GetDomainClass(rootElement.DomainClassId); if (rootElementDomainInfo.IsDerivedFrom(ElementSchema.DomainClassId) || rootElementDomainInfo.IsDerivedFrom(CollectionSchema.DomainClassId) || rootElementDomainInfo.IsDerivedFrom(ExtensionPointSchema.DomainClassId)) { return(true); } } return(base.CanMerge(rootElement, elementGroupPrototype)); }
/// <summary> /// Determines whether this instance [can merge layer] the specified root element. /// </summary> /// <param name="rootElement">The root element.</param> /// <param name="elementGroupPrototype">The element group prototype.</param> /// <returns> /// <c>true</c> if this instance [can merge layer] the specified root element; otherwise, <c>false</c>. /// </returns> private bool CanMergeLayer(ProtoElementBase rootElement, ElementGroupPrototype elementGroupPrototype) { if (elementGroupPrototype == null) { throw new ArgumentNullException("elementGroupPrototype"); } if (rootElement != null) { DomainClassInfo rootElementDomainInfo = Partition.DomainDataDirectory.GetDomainClass(rootElement.DomainClassId); if (rootElementDomainInfo.IsDerivedFrom(Layer.DomainClassId)) { return(Component.GetLayerLevel(rootElement.DomainClassId) == Level); } } return(false); }
private IEnumerable <ModelElement> ExtractElements(IDataObject data) { if (data != null) { if (data.GetDataPresent(typeof(ElementGroupPrototype))) { ElementGroupPrototype groupPrototype = (ElementGroupPrototype)data.GetData(typeof(ElementGroupPrototype)); if (groupPrototype != null) { IElementDirectory elementDir = Store.ElementDirectory; foreach (ProtoElement proto in groupPrototype.RootProtoElements) { ModelElement element; if (null != (element = elementDir.FindElement(proto.ElementId))) { yield return(element); } } } } else { Store store = Store; DomainDataDirectory dataDirectory = store.DomainDataDirectory; foreach (string possibleClassName in data.GetFormats(false)) { DomainClassInfo classInfo; DomainClassInfo elementClassInfo; ModelElement element; if (null != (classInfo = dataDirectory.FindDomainClass(possibleClassName)) && null != (element = data.GetData(possibleClassName) as ModelElement) && element.Store == store && ((elementClassInfo = element.GetDomainClass()) == classInfo || elementClassInfo.IsDerivedFrom(classInfo))) { yield return(element); } } } } }
protected override ModelElement ChooseMergeTarget(ElementGroupPrototype elementGroupPrototype) { return base.ChooseMergeTarget(elementGroupPrototype); }
/// <summary> /// Construct a new model note action for a specific diagram. The /// same action can be reused multiple times by activating and /// deactivating it. /// </summary> /// <param name="diagram">The owning diagram</param> /// <param name="prototype">The prototype of the current toolbox item.</param> public ModelNoteAction(Diagram diagram, ElementGroupPrototype prototype) : base(diagram, prototype) { Reset(); }
/// <summary> /// Construct a new constraint action for a specific diagram. The /// same connect action can be reused multiple times by activating and /// deactivating it. /// </summary> /// <param name="diagram">The owning diagram</param> /// <param name="prototype">The prototype of the current toolbox item.</param> public InternalUniquenessConstraintAction(Diagram diagram, ElementGroupPrototype prototype) : base(diagram, prototype) { Reset(); }
public override void MergeElementGroupPrototype(ModelElement targetElement, ElementGroupPrototype elementGroupPrototype) { int i = 5; base.MergeElementGroupPrototype(targetElement, elementGroupPrototype); }
/// <summary> /// Create a new toolbox action. One instance of this class /// should be created per distinct toolbox item for each /// diagram instance. /// </summary> /// <param name="diagram">The current diagram.</param> /// <param name="prototype">The group prototype, retrieved from the /// <see cref="ModelingToolboxItem.Prototype"/> property.</param> public ElementPrototypeToolboxAction(Diagram diagram, ElementGroupPrototype prototype) : base(diagram) { myCursor = Cursors.No; myPrototype = prototype; }
//Prevent pasting of sockets protected override bool CanMerge(ProtoElementBase rootElement, ElementGroupPrototype elementGroupPrototype) { return(false); }
internal virtual bool internalCanMerge(VDWidget origianlTargetWidget, ProtoElementBase sourceRootElement, ElementGroupPrototype elementGroupPrototype) { if (elementGroupPrototype == null) { throw new ArgumentNullException("elementGroupPrototype"); } if (sourceRootElement != null) { DomainClassInfo rootElementDomainInfo = this.Partition.DomainDataDirectory.GetDomainClass(sourceRootElement.DomainClassId); if (rootElementDomainInfo.IsDerivedFrom(VDWidget.DomainClassId)) { return(MergeManager.Instance.CanMerge(rootElementDomainInfo.Id, this.GetDomainClass().Id)); } } return(base.CanMerge(sourceRootElement, elementGroupPrototype)); }
/// <summary> /// Construct a new constraint action for a specific diagram. The /// same connect action can be reused multiple times by activating and /// deactivating it. /// </summary> /// <param name="diagram">The owning diagram</param> /// <param name="prototype">The prototype of the current toolbox item.</param> public ExternalConstraintAction(Diagram diagram, ElementGroupPrototype prototype) : base(diagram, prototype) { Reset(); }
protected override ModelElement ChooseMergeTarget(ElementGroupPrototype elementGroupPrototype) { return(base.ChooseMergeTarget(elementGroupPrototype)); }
/// <summary> /// Returns a value indicating whether the source element represented by the /// specified root ProtoElement can be added to this element. /// </summary> /// <param name="rootElement"> /// The root ProtoElement representing a source element. This can be null, /// in which case the ElementGroupPrototype does not contain an ProtoElements /// and the code should inspect the ElementGroupPrototype context information. /// </param> /// <param name="elementGroupPrototype">The ElementGroupPrototype that contains the root ProtoElement.</param> /// <returns>true if the source element represented by the ProtoElement can be added to this target element.</returns> protected override bool CanMerge(ProtoElementBase rootElement, ElementGroupPrototype elementGroupPrototype) { return(internalCanMerge(this, rootElement, elementGroupPrototype)); }