/// <summary>
        /// Callback from SelectionChangedEvent.
        /// </summary>
        /// <param name="eventArgs">SelectionChangedEventArgs.</param>
        private void ReactOnViewSelection(SelectionChangedEventArgs eventArgs)
        {
            this.selectedModelElement = null;

            if (eventArgs.SelectedItems != null)
                if (eventArgs.SelectedItems.Count == 1)
                    this.selectedModelElement = eventArgs.SelectedItems[0] as DomainModelElement;
        }
Esempio n. 2
0
        /// <summary>
        /// Verifies if the given model element belongs to the domain model (can be reached from the domain model element).
        /// </summary>
        /// <param name="modelContextId">Model context Id.</param>
        /// <param name="modelElement">Model element.</param>
        /// <returns>True if the element belongs to the domain model. False otherwise.</returns>
        public bool IsIncludedInModel(Guid modelContextId, DomainModelElement modelElement)
        {
            if (modelElement == null)
            {
                return(false);
            }

            return(IsIncludedInModel(modelContextId, modelElement.GetDomainClassId()));
        }
Esempio n. 3
0
        /// <summary>
        /// Verifies if the given reference link belongs to the domain model (can be reached from the domain model element).
        /// </summary>
        /// <param name="modelLinkDCId">Model link domain class Id.</param>
        /// <param name="modelContextId">Model context Id.</param>
        /// <returns>True if the refrence link belongs to the domain model. False otherwise.</returns>
        public bool IsReferenceIncludedInModel(Guid modelContextId, Guid modelLinkDCId)
        {
            DomainRelationshipInfo info = this.Store.DomainDataDirectory.FindDomainRelationship(modelLinkDCId);

            if (IsIncludedInModel(modelContextId, DomainModelElement.GetSourceDomainRole(info).RolePlayer.Id))
            {
                return(true);
            }

            if (IsIncludedInModel(modelContextId, DomainModelElement.GetTargetDomainRole(info).RolePlayer.Id))
            {
                return(true);
            }

            return(false);
        }
Esempio n. 4
0
        /// <summary>
        /// Verifies if the given reference link belongs to the domain model (can be reached from the domain model element).
        /// </summary>
        /// <param name="modelLink">Model link.</param>
        /// <param name="modelContextId">Model context Id.</param>
        /// <returns>True if the refrence link belongs to the domain model. False otherwise.</returns>
        public bool IsReferenceIncludedInModel(Guid modelContextId, DomainModelLink modelLink)
        {
            if (modelLink.IsEmbedding)
            {
                return(false);
            }

            DomainModelElement m = DomainRoleInfo.GetSourceRolePlayer(modelLink) as DomainModelElement;

            if (IsIncludedInModel(modelContextId, m))
            {
                return(true);
            }

            m = DomainRoleInfo.GetTargetRolePlayer(modelLink) as DomainModelElement;
            if (IsIncludedInModel(modelContextId, m))
            {
                return(true);
            }

            return(false);
        }
Esempio n. 5
0
        private void ProcessInitializationInfo(Guid modelContextId, Guid domainClassId, List <Guid> processedClasses)
        {
            EmbeddingRelationshipOrderInfo info;

            this.embRelationshipOrderDictionary.TryGetValue(domainClassId, out info);

            if (info != null)
            {
                parentChildrenMapping[modelContextId].Add(domainClassId, new List <Guid>());
                parentChildrenMapping[modelContextId][domainClassId].AddRange(info.EmbeddingRelationships);

                parentChildrenCMMapping[modelContextId].Add(domainClassId, new List <Guid>());
                parentChildrenCMMapping[modelContextId][domainClassId].AddRange(info.EmbeddingRelationshipsTargetIncludedSubmodel);

                for (int i = 0; i < info.EmbeddingRelationships.Length; i++)
                {
                    DomainRelationshipInfo rInfo = this.Store.DomainDataDirectory.GetDomainRelationship(info.EmbeddingRelationships[i]);
                    DomainClassInfo        cInfo = DomainModelElement.GetTargetDomainRole(rInfo).RolePlayer;

                    if (!processedClasses.Contains(cInfo.Id))
                    {
                        processedClasses.Add(cInfo.Id);
                        ProcessInitializationInfo(modelContextId, cInfo.Id, processedClasses);
                    }

                    foreach (DomainClassInfo dInfo in cInfo.AllDescendants)
                    {
                        if (!processedClasses.Contains(dInfo.Id))
                        {
                            processedClasses.Add(dInfo.Id);
                            ProcessInitializationInfo(modelContextId, dInfo.Id, processedClasses);
                        }
                    }
                }
            }
        }
 /// <summary>
 /// Constructor. The view model constructed this way does not react on model changes, as such DoHookUpEvents is false.
 /// </summary>
 /// <param name="viewModelStore">The store this view model belongs to.</param>
 /// <param name="element">Element represented by this view model.</param>
 public ExampleElementViewModel(ViewModelStore viewModelStore, DomainModelElement element)
     : base(viewModelStore, element)
 {
     LocalChildrenCount = element.GetLocalChildren().Count.ToString();
     ChildrenCount = element.GetChildren().Count.ToString();
 }
Esempio n. 7
0
        /// <summary>
        /// Adds a proto element to the current element.
        /// </summary>
        /// <param name="protoElement">Proto element representation of the element that is to be added.</param>
        /// <param name="groupMerger">
        /// Group merger class used to track id mapping, merge errors/warnings and
        /// postprocess merging by rebuilding reference relationships.
        /// </param>
        /// <param name="isRoot">Root element?</param>
        public virtual void ModelMerge(ModelProtoElement protoElement, ModelProtoGroupMerger groupMerger, bool isRoot)
        {
            if (!ModelIsPasteAllowed(groupMerger.ProtoGroup.Operation))
            {
                // add warning message
                groupMerger.MergeResult.AddMessage(new ValidationMessage(ModelValidationMessageIds.ModelMergePasteDisallowedId,
                                                                         ModelValidationViolationType.Warning, "Element couldn't be addded to " + this.DomainElementFullName + " because paste is not allowed."));
                return;
            }

            if (protoElement != null)
            {
                DomainClassInfo elementDomainInfo = this.Partition.DomainDataDirectory.GetDomainClass(protoElement.DomainClassId);
                foreach (DomainRoleInfo info in elementDomainInfo.AllDomainRolesPlayed)
                {
                    if (!info.IsSource)
                    {
                        if (info.OppositeDomainRole.RolePlayer.Id == this.GetDomainClassId())
                        {
                            if (this.Store.DomainDataAdvDirectory.IsEmbeddingRelationship(info.DomainRelationship.Id) &&
                                !this.Store.DomainDataAdvDirectory.IsAbstractRelationship(info.DomainRelationship.Id))
                            {
                                // create element id
                                Guid newElementId = this.GetDomainModelServices().ElementIdProvider.GenerateNewKey();

                                // create property assignments
                                PropertyAssignment[] propertyAssignemnts = protoElement.GetPropertyAssignments(this.Store.DefaultPartition, newElementId);

                                // create the actual model element
                                DomainModelElement element = this.Store.ElementFactory.CreateElement(elementDomainInfo, propertyAssignemnts) as DomainModelElement;
                                if (element == null)
                                {
                                    throw new System.ArgumentNullException("Element is null in ModelMerge: " + elementDomainInfo.Name);
                                }

                                if (!element.ModelIsPasteAllowed(groupMerger.ProtoGroup.Operation))
                                {
                                    // add warning message
                                    groupMerger.MergeResult.AddMessage(new ValidationMessage(ModelValidationMessageIds.ModelMergePasteDisallowedId,
                                                                                             ModelValidationViolationType.Warning, "Element couldn't be addded to <#= role.RolePlayer.Name #> because paste is not allowed."));

                                    element.Delete();
                                    return;
                                }

                                // set name
                                if (isRoot && groupMerger.ProtoGroup.Operation != ModelProtoGroupOperation.Move)
                                {
                                    if (element.DomainElementHasName)
                                    {
                                        element.GetDomainModelServices().ElementNameProvider.SetName(element, "Copy of " + element.DomainElementName);
                                    }
                                }

                                // update id mapping
                                groupMerger.SetIdMapping(protoElement.ElementId, newElementId);

                                // add child element
                                if (info.OppositeDomainRole.Multiplicity == Multiplicity.One || info.OppositeDomainRole.Multiplicity == Multiplicity.ZeroOne)
                                {
                                    DomainRoleInfo.SetLinkedElement(this, info.OppositeDomainRole.Id, element);
                                }
                                else
                                {
                                    RoleAssignment[] assignments = new RoleAssignment[2];
                                    assignments[0] = new RoleAssignment(info.OppositeDomainRole.Id, this);
                                    assignments[1] = new RoleAssignment(info.Id, element);


                                    this.Store.ElementFactory.CreateElementLink(info.DomainRelationship, assignments);
                                }

                                // continue with child elements (Embedding Relationship)
                                System.Collections.Generic.List <ModelProtoElement> embeddedProtoElements = groupMerger.GetEmbeddedElements(this.Store.DefaultPartition, protoElement);
                                if (embeddedProtoElements.Count > 0)
                                {
                                    foreach (ModelProtoElement p in embeddedProtoElements)
                                    {
                                        (element as IModelMergeElements).ModelMerge(p, groupMerger, false);
                                    }
                                }

                                return;
                            }
                        }
                    }
                }
            }
        }
Esempio n. 8
0
        /// <summary>
        /// Processes a proto element representation of the element and adds required proto links.
        /// This method is called on base classes from derived classes.
        ///
        /// Hint: Properties do not need to be added in this method.
        /// </summary>
        /// <param name="protoElement">Proto element representation of the element.</param>
        /// <param name="protoGroup">Proto group the proto element belongs to.</param>
        public virtual void ModelProcessMergeCopy(ModelProtoElement protoElement, ModelProtoGroup protoGroup)
        {
            foreach (ElementLink link in DomainRoleInfo.GetAllElementLinks(this))
            {
                if (link is DomainModelLink)
                {
                    DomainModelLink modelLink           = link as DomainModelLink;
                    DomainRelationshipAdvancedInfo info = this.Store.DomainDataAdvDirectory.GetRelationshipInfo(modelLink.GetDomainClassId());
                    if (info is ReferenceRelationshipAdvancedInfo)
                    {
                        if (DomainRoleInfo.GetSourceRolePlayer(modelLink) == this)
                        {
                            if (!(info as ReferenceRelationshipAdvancedInfo).PropagatesCopyToTarget)
                            {
                                continue;
                            }
                        }
                        else
                        if (!(info as ReferenceRelationshipAdvancedInfo).PropagatesCopyToSource)
                        {
                            continue;
                        }

                        ModelProtoLink protoLink = new ModelProtoLink(link);
                        protoGroup.AddNewReferenceLink(protoLink);
                    }
                    else
                    {
                        DomainModelElement child = DomainRoleInfo.GetTargetRolePlayer(link) as DomainModelElement;
                        if (child == this || child == null)
                        {
                            continue;
                        }
                        if ((info as EmbeddingRelationshipAdvancedInfo).PropagatesCopyToChild)
                        {
                            if (!(info as EmbeddingRelationshipAdvancedInfo).IsTargetIncludedSubmodel)
                            {
                                ModelProtoLink protoLink = new ModelProtoLink(link);
                                protoGroup.AddNewEmbeddingLink(protoLink);
                                child.ModelCreateMergeCopy(protoGroup);
                            }
                            else if (child is IParentModelElement)
                            {
                                ModelProtoLink protoLink = new ModelProtoLink(link);
                                protoLink.IsTargetIncludedSubmodel = true;
                                protoLink.DomainFilePath           = (child as IParentModelElement).DomainFilePath;
                                protoGroup.AddNewReferenceLink(protoLink);
                            }
                        }
                    }
                }
            }

            /*
             * // process reference relationships
             * List<ReferenceRelationshipAdvancedInfo> infos = this.Store.DomainDataAdvDirectory.FindDomainClassSourceReferences(this.GetDomainClassId());
             * if (infos != null)
             *  foreach (ReferenceRelationshipAdvancedInfo info in infos)
             *  {
             *      if (info.PropagatesCopyToTarget)
             *      {
             *          System.Collections.ObjectModel.ReadOnlyCollection<ElementLink> links = DomainRoleInfo.GetElementLinks<ElementLink>(this, info.SourceRoleId);
             *          foreach (ElementLink link in links)
             *          {
             *              ModelProtoLink protoLink = new ModelProtoLink(link);
             *              protoGroup.AddNewReferenceLink(protoLink);
             *          }
             *      }
             *  }
             * infos = this.Store.DomainDataAdvDirectory.FindDomainClassTargetReferences(this.GetDomainClassId());
             * if (infos != null)
             *  foreach (ReferenceRelationshipAdvancedInfo info in infos)
             *  {
             *      if (info.PropagatesCopyToSource)
             *      {
             *          System.Collections.ObjectModel.ReadOnlyCollection<ElementLink> links = DomainRoleInfo.GetElementLinks<ElementLink>(this, info.TargetRoleId);
             *          foreach (ElementLink link in links)
             *          {
             *              ModelProtoLink protoLink = new ModelProtoLink(link);
             *              protoGroup.AddNewReferenceLink(protoLink);
             *          }
             *      }
             *  }
             *
             * // process embedding relationships
             * List<EmbeddingRelationshipAdvancedInfo> infosEmb = this.Store.DomainDataAdvDirectory.FindDomainClassSourceEmbeddings(this.GetDomainClassId());
             * if (infosEmb != null)
             *  foreach (EmbeddingRelationshipAdvancedInfo info in infosEmb)
             *  {
             *      if (info.PropagatesCopyToChild)
             *      {
             *          System.Collections.ObjectModel.ReadOnlyCollection<ElementLink> links = DomainRoleInfo.GetElementLinks<ElementLink>(this, info.SourceRoleId);
             *          foreach (ElementLink link in links)
             *          {
             *              ModelProtoLink protoLink = new ModelProtoLink(link);
             *              protoGroup.AddNewEmbeddingLink(protoLink);
             *
             *              DomainModelElement child = DomainRoleInfo.GetTargetRolePlayer(link) as DomainModelElement;
             *              if( child != null )
             *                  child.ModelCreateMergeCopy(protoGroup);
             *          }
             *      }
             *  }
             */
        }
Esempio n. 9
0
 /// <summary>
 /// Verifies if the given model element belongs to the domain model (can be reached from the domain model element).
 /// </summary>
 /// <param name="modelElement">Model element.</param>
 /// <returns>True if the element belongs to the domain model. False otherwise.</returns>
 public bool IsIncludedInModel(DomainModelElement modelElement)
 {
     return(IsIncludedInModel(Guid.Empty, modelElement));
 }