/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> public ModelContextViewModel(ViewModelStore viewModelStore, BaseModelContext baseModelContext, bool isLocked) : base(viewModelStore) { this.modelContext = baseModelContext; this.copyCommand = new DelegateCommand(CopyCommand_Executed, CopyCommand_CanExecute); this.pasteCommand = new DelegateCommand(PasteCommand_Executed, PasteCommand_CanExecute); this.copyAllTreeCommand = new DelegateCommand(CopyAllTreeCommand_Executed, CopyAllTreeCommand_CanExecute); this.copyEmbeddingTreeCommand = new DelegateCommand(CopyEmbeddingTreeCommand_Executed, CopyAllTreeCommand_CanExecute); this.copyReferenceTreeCommand = new DelegateCommand(CopyReferenceTreeCommand_Executed, CopyAllTreeCommand_CanExecute); //this.cutCommand = new DelegateCommand(CutCommand_Executed, CutCommand_CanExecute); this.optimizeCommand = new DelegateCommand(OptimizeCommand_Executed); if (baseModelContext is ModelContext) { ModelContext modelContext = baseModelContext as ModelContext; this.modelTreeViewModel = new ModelTreeViewModel(viewModelStore, this, modelContext.ViewContext.DomainModelTreeView); this.modelTreeViewModel.IsLocked = isLocked; this.diagramViewModel = new DiagramViewModel(viewModelStore, this, modelContext.ViewContext.DiagramView); this.serializationViewModel = new SerializationViewModel(viewModelStore, modelContext.SerializationModel); this.modelContextType = ModelContextViewType.ModelContext; } else if( baseModelContext is ExternModelContext) { ExternModelContext modelContext = baseModelContext as ExternModelContext; if (modelContext.ModelContext != null) { this.AddModelContext(modelContext.ModelContext); } this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(ExternModelContextReferencesModelContext.DomainClassId), true, this.modelContext.Id, new System.Action<ElementAddedEventArgs>(OnModelContextAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(ExternModelContextReferencesModelContext.DomainClassId), true, this.modelContext.Id, new System.Action<ElementDeletedEventArgs>(OnModelContextRemoved)); this.EventManager.GetEvent<ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(ExternModelContextReferencesModelContext.ExternModelContextDomainRoleId), new System.Action<RolePlayerChangedEventArgs>(OnModelContextChanged)); this.EventManager.GetEvent<ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(ExternModelContextReferencesModelContext.ModelContextDomainRoleId), new System.Action<RolePlayerChangedEventArgs>(OnModelContextChanged)); this.modelContextType = ModelContextViewType.ExternModelContext; } else if (baseModelContext is LibraryModelContext) { LibraryModelContext modelContext = baseModelContext as LibraryModelContext; this.modelTreeViewModel = new ModelTreeViewModel(viewModelStore, this, modelContext.ViewContext.DomainModelTreeView); this.modelTreeViewModel.IsLocked = isLocked; this.diagramViewModel = new DiagramViewModel(viewModelStore, this, modelContext.ViewContext.DiagramView); this.modelContextType = ModelContextViewType.LibraryContext; this.serializationViewModel = new SerializationViewModel(viewModelStore, modelContext.SerializationModel); } this.selectedItem = this.ModelTreeViewModel; if( this.ModelContext != null ) this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe( this.Store.DomainDataDirectory.GetDomainProperty(BaseModelContext.NameDomainPropertyId), this.ModelContext.Id, new System.Action<ElementPropertyChangedEventArgs>(NamePropertyChanged)); }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="serializedRelationship">SerializedRelationship.</param> /// <param name="referencedElement">Element that is referenced by the serialization element. Can be null.</param> protected SerializedRelationshipViewModel(ViewModelStore viewModelStore, SerializedRelationship serializedRelationship, DomainRelationship referencedElement, SerializationClassViewModel parent) : base(viewModelStore, serializedRelationship, referencedElement, parent) { if (this.SerializationElement != null) { // subscribe this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.SerializationElement.Id, new Action<ElementPropertyChangedEventArgs>(OnSerializationRelationshipropertyChanged)); if (this.SerializationElement.SerializedDomainRoles.Count > 0) { sourceRoleVM = new SerializedDomainRoleViewModel(this.ViewModelStore, this.SerializationElement.SerializedDomainRoles[0], referencedElement, this); this.AddChild(sourceRoleVM); } if (this.SerializationElement.SerializedDomainRoles.Count > 1) { targetRoleVM = new SerializedDomainRoleViewModel(this.ViewModelStore, this.SerializationElement.SerializedDomainRoles[1], referencedElement, this); if (targetRoleVM.SerializationElement.SerializationClass is SerializedDomainClass) targetClassVM = new SerializedDomainClassViewModel(this.ViewModelStore, targetRoleVM.SerializationElement.SerializationClass as SerializedDomainClass, this); else if (targetRoleVM.SerializationElement.SerializationClass is SerializedReferenceRelationship) targetClassVM = new SerializedReferenceRelationshipViewModel(this.ViewModelStore, targetRoleVM.SerializationElement.SerializationClass as SerializedReferenceRelationship, this); this.AddChild(targetRoleVM); } } }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="modelTreeView">Diagram tree view.</param> public SerializationViewModel(ViewModelStore viewModelStore, SerializationModel serializationModel) : base(viewModelStore) { this.allVMs = new ObservableCollection<SerializedDomainModelViewModel>(); this.serializationModel = serializationModel; this.selectedVMS = new Collection<object>(); this.rootVMs = new ObservableCollection<SerializedDomainModelViewModel>(); this.rootVMsRO = new ReadOnlyObservableCollection<SerializedDomainModelViewModel>(this.rootVMs); this.selectRelationshipCommand = new DelegateCommand(SelectRelationshipCommand_Executed); this.moveUpCommand = new DelegateCommand(MoveUpCommand_Executed, MoveUpCommand_CanExecute); this.moveDownCommand = new DelegateCommand(MoveDownCommand_Executed, MoveDownCommand_CanExecute); if (this.serializationModel.SerializedDomainModel != null) { this.rootVMs.Add(new SerializedDomainModelViewModel(this.ViewModelStore, this.serializationModel.SerializedDomainModel)); } if (this.serializationModel != null) { foreach (SerializationClass c in this.serializationModel.Children) if (c is SerializedDomainClass) this.AddChild(c as SerializedDomainClass); this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationModelHasChildren.DomainClassId), true, this.serializationModel.Id, new System.Action<ElementAddedEventArgs>(OnChildAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationModelHasChildren.DomainClassId), true, this.serializationModel.Id, new System.Action<ElementDeletedEventArgs>(OnChildRemoved)); } }
{ /// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="serializedRelationship">SerializedRelationship.</param> /// <param name="referencedElement">Element that is referenced by the serialization element. Can be null.</param> public SerializedReferenceRelationshipViewModel(ViewModelStore viewModelStore, SerializedReferenceRelationship serializedRelationship, SerializationClassViewModel parent) : base(viewModelStore, serializedRelationship, serializedRelationship.ReferenceRelationship, parent) { if( this.SerializationElement != null ) if (this.SerializationElement.ReferenceRelationship != null) this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.SerializationElement.ReferenceRelationship.Id, new Action<ElementPropertyChangedEventArgs>(OnSerializedReferenceRelationshipPropertyChanged)); }
/// <summary> /// Constructor. This view model constructed with 'bHookUpEvents=true' does react on model changes. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="diagramTreeNode">Element represented by this view model.</param> protected DiagramTreeNodeViewModel(ViewModelStore viewModelStore, DiagramTreeNode diagramTreeNode) : base(viewModelStore, diagramTreeNode.PresentationElementClass) { this.diagramTreeNode = diagramTreeNode; if (this.DiagramTreeNode != null) if (this.DiagramTreeNode.PresentationElementClass != null) { presentationElementClassId = this.DiagramTreeNode.PresentationElementClass.Id; this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(ShapeClassReferencesDomainClass.DomainClassId), true, this.DiagramTreeNode.PresentationElementClass.Id, new Action<ElementAddedEventArgs>(OnShapeElementAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(ShapeClassReferencesDomainClass.DomainClassId), true, this.DiagramTreeNode.PresentationElementClass.Id, new Action<ElementDeletedEventArgs>(OnShapeElementRemoved)); this.EventManager.GetEvent<ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(ShapeClassReferencesDomainClass.DomainClassDomainRoleId), new Action<RolePlayerChangedEventArgs>(OnShapeElementChanged)); this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(RelationshipShapeClassReferencesReferenceRelationship.DomainClassId), true, this.DiagramTreeNode.PresentationElementClass.Id, new Action<ElementAddedEventArgs>(OnRSShapeElementAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(RelationshipShapeClassReferencesReferenceRelationship.DomainClassId), true, this.DiagramTreeNode.PresentationElementClass.Id, new Action<ElementDeletedEventArgs>(OnRSShapeElementRemoved)); this.EventManager.GetEvent<ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(RelationshipShapeClassReferencesReferenceRelationship.DomainRelationshipDomainRoleId), new Action<RolePlayerChangedEventArgs>(OnRSShapeElementChanged)); if (this.DiagramTreeNode.PresentationElementClass is RelationshipShapeClass) AddRSShapeElement((this.DiagramTreeNode.PresentationElementClass as RelationshipShapeClass).ReferenceRelationship); else AddShapeElement((this.DiagramTreeNode.PresentationElementClass as PresentationDomainClassElement).DomainClass); } }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> public MainSurfaceViewModel(ViewModelStore viewModelStore) : base(viewModelStore) { this.rootNodeVMs = new ObservableCollection<ModelContextViewModel>(); this.rootNodeVMsRO = new ReadOnlyObservableCollection<ModelContextViewModel>(this.rootNodeVMs); if (this.ModelData.MetaModel != null) { foreach (BaseModelContext mc in this.ModelData.MetaModel.ModelContexts) AddModelContext(mc); // subscribe this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(MetaModelHasModelContexts.DomainClassId), true, this.ModelData.MetaModel.Id, new Action<ElementAddedEventArgs>(OnModelContextAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(MetaModelHasModelContexts.DomainClassId), true, this.ModelData.MetaModel.Id, new Action<ElementDeletedEventArgs>(OnModelContextRemoved)); if (this.ModelContextVMs.Count > 0) this.selectedItem = this.ModelContextVMs[0]; } this.EventManager.GetEvent<SelectionChangedEvent>().Subscribe(new Action<SelectionChangedEventArgs>(OnSelectionChanged)); }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> public DataTemplateViewModel(ViewModelStore viewModelStore, string templateDisplayName, string dataTemplate) : base(viewModelStore) { this.DisplayName = templateDisplayName; this.DataTemplate = dataTemplate; this.SyntaxHighlighting = "C#"; }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="text">Text of the menu item.</param> /// <param name="iconUrl">Icon of the menu item.</param> public MenuItemViewModel(ViewModelStore viewModelStore, string text, string iconUrl) : base(viewModelStore) { itemText = text; itemIconUrl = iconUrl; itemChildren = new ObservableCollection<MenuItemViewModel>(); }
protected override void Load(string fileName, bool isReload) { MetaModel.BaseGlobalDirectory = MetaModelLibraryBase.GetBaseDirectory(fileName); LoadVModell(fileName, isReload); MetaModel model = this.RootElement as MetaModel; model.IsTopMost = true; // set locks to imported libraries SetLocksToImportedLibraries(model); // create model data, store and view model ModelData = new ModelData(model); ViewModelStore = new ViewModelStore(ModelData); ViewModel = new MainSurfaceViewModel(ViewModelStore); // register known windows try { IUIVisualizerService popupVisualizer = ViewModel.GlobalServiceProvider.Resolve<IUIVisualizerService>(); popupVisualizer.Register("TargetSelectorForm", typeof(TargetSelectorForm)); popupVisualizer.Register("CategorizedSelectionPopup", typeof(CategorizedSelectionPopup)); popupVisualizer.Register("DiagramClassTemplateSelector", typeof(DiagramClassTemplateSelector)); popupVisualizer.Register("DataTemplatePresetsPopup", typeof(DataTemplatePresetsPopup)); popupVisualizer.Register("OptimizationControl", typeof(OptimizationControl)); } catch { } }
/// <summary> /// Constructor. This view model constructed with 'bHookUpEvents=true' does react on model changes. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="embeddingDiagramNode">Element represented by this view model.</param> public EmbeddingDiagramNodeViewModel(ViewModelStore viewModelStore, EmbeddingDiagramNode embeddingDiagramNode, EmbeddingDiagramNodeViewModel parent) : base(viewModelStore, embeddingDiagramNode) { this.parent = parent; this.embeddingNodeVMs = new ObservableCollection<EmbeddingDiagramNodeViewModel>(); this.embeddingNodeVMsRO = new ReadOnlyObservableCollection<EmbeddingDiagramNodeViewModel>(this.embeddingNodeVMs); if (this.EmbeddingDiagramNode != null) { foreach (EmbeddingDiagramNode node in this.EmbeddingDiagramNode.EmbeddingDiagramNodes) this.AddEmbeddingDiagramNode(node); this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.EmbeddingDiagramNode.Id, new Action<ElementPropertyChangedEventArgs>(OnElementPropertyChanged)); this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.DomainClassId), true, this.EmbeddingDiagramNode.Id, new Action<ElementAddedEventArgs>(OnEmbeddingDiagramNodeAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.DomainClassId), true, this.EmbeddingDiagramNode.Id, new Action<ElementDeletedEventArgs>(OnEmbeddingDiagramNodeRemoved)); this.EventManager.GetEvent<ModelRolePlayerMovedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.DomainClassId), this.EmbeddingDiagramNode.Id, new Action<RolePlayerOrderChangedEventArgs>(OnEmbeddingDiagramNodeMoved)); this.EventManager.GetEvent<ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.SourceEmbeddingDiagramNodeDomainRoleId), new Action<RolePlayerChangedEventArgs>(OnEmbeddingDiagramNodeChanged)); } expandCollapseTreeCommand = new DelegateCommand(ExpandCollapseTreeCommand_Executed); }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="ribbonViewModel">Ribbon view model to be assigned to this view.</param> protected BaseHostingViewModel(ViewModelStore viewModelStore) : base(viewModelStore) { // init commands //activatedCommand = new DelegateCommand(OnActivated); loadedCommand = new DelegateCommand(OnLoaded); unloadedCommand = new DelegateCommand(OnUnloaded); }
/// <summary> /// Constructor. This view model constructed with 'bHookUpEvents=true' does react on model changes. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="element">Element represented by this view model.</param> public IncludedDiagramClassViewModel(ViewModelStore viewModelStore, DiagramClass element, DesignerDiagramClass diagramClass) : base(viewModelStore, element, true) { this.diagramClass = diagramClass; this.linkId = GetHostedElement().Id; this.IsLocked = false; }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="referenceRSNode">ReferenceRSNode.</param> /// <param name="parent">Parent.</param> public DomainRoleViewModel(ViewModelStore viewModelStore, DomainRole role, DomainRelationshipViewModel parent) : base(viewModelStore, role.Relationship) { this.parentVM = parent; this.domainRole = role; this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.Role.Id, new Action<ElementPropertyChangedEventArgs>(OnRolePropertyChanged)); }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="serializedIdProperty">SerializedIdProperty.</param> public SerializedIdPropertyViewModel(ViewModelStore viewModelStore, SerializedIdProperty serializedIdProperty, SerializationClassViewModel parent) : base(viewModelStore, serializedIdProperty, null, parent) { if (this.SerializationElement != null) { // subscribe this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.SerializationElement.Id, new Action<ElementPropertyChangedEventArgs>(OnSerializedIdPropertyPropertyChanged)); } }
{ /// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="serializedRelationship">SerializedRelationship.</param> /// <param name="referencedElement">Element that is referenced by the serialization element. Can be null.</param> public SerializedEmbeddingRelationshipViewModel(ViewModelStore viewModelStore, SerializedEmbeddingRelationship serializedRelationship, SerializationClassViewModel parent) : base(viewModelStore, serializedRelationship, serializedRelationship.EmbeddingRelationship, parent) { if (this.SerializationElement.EmbeddingRelationship != null) { this.sourceRoleVM = new SerializedDomainRoleViewModel(this.ViewModelStore, this.SerializationElement.EmbeddingRelationship.Source, this.SerializationElement.EmbeddingRelationship, this); this.targetRoleVM = new SerializedDomainRoleViewModel(this.ViewModelStore, this.SerializationElement.EmbeddingRelationship.Target, this.SerializationElement.EmbeddingRelationship, this); } }
public static CategorizedSelectionViewModel CreateCategorizedVM(MetaModel model, ViewModelStore store, SelectionHelperTarget target) { // categories for main meta model as well as imported ones List<MetaModel> handledMetaModels = new List<MetaModel>(); List<CategorizedAdvSelectableViewModel> modelCategoryVMs = new List<CategorizedAdvSelectableViewModel>(); CreateCategorizedVM(model, store, target, handledMetaModels, modelCategoryVMs); return new CategorizedSelectionViewModel(store, modelCategoryVMs); }
public static CategorizedSelectionViewModel CreateCategorizedVMWithoutImported(MetaModel model, ViewModelStore store, SelectionHelperTarget target) { // categories for main meta model as well as imported ones List<CategorizedAdvSelectableViewModel> modelCategoryVMs = new List<CategorizedAdvSelectableViewModel>(); CategorizedAdvSelectableViewModel modelCategoryVM = CreateCategorizedAdvSelectableVM(model, model.Name, store, target); modelCategoryVMs.Add(modelCategoryVM); return new CategorizedSelectionViewModel(store, modelCategoryVMs); }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="serializationClass">SerializationClass.</param> /// <param name="referencedElement">Element that is referenced by the serialization element. Can be null.</param> protected SerializationClassViewModel(ViewModelStore viewModelStore, SerializationClass serializationClass, ModelElement referencedElement, SerializationClassViewModel parent) : base(viewModelStore, serializationClass, referencedElement) { this.childrenVMs = new ObservableCollection<SerializationElementViewModel>(); this.childrenVMsRO = new ReadOnlyObservableCollection<SerializationElementViewModel>(this.childrenVMs); this.attributesVMs = new ObservableCollection<SerializationAttributeElementViewModel>(); this.attributesVMsRO = new ReadOnlyObservableCollection<SerializationAttributeElementViewModel>(attributesVMs); this.parent = parent; if (this.SerializationElement != null) { // Lazy load the child items, if necessary. if (this.HasLoadedChildren) { this.LoadChildren(); } else if (this.SerializationElement.Children.Count > 0) this.childrenVMs.Add(DummyChild); this.LoadAttributes(); /* // Lazy load the attribute items, if necessary. if (!this.HasLoadedAttributes) { this.LoadAttributes(); } else if (this.SerializationElement.Attributes.Count > 0) this.attributesVMs.Add(DummyAttribute); */ // subscribe this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.SerializationElement.Id, new Action<ElementPropertyChangedEventArgs>(OnSerializationClassPropertyChanged)); this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationClassReferencesChildren.DomainClassId), true, this.SerializationElement.Id, new Action<ElementAddedEventArgs>(OnChildAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationClassReferencesChildren.DomainClassId), true, this.SerializationElement.Id, new Action<ElementDeletedEventArgs>(OnChildRemoved)); this.EventManager.GetEvent<ModelRolePlayerMovedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationClassReferencesChildren.DomainClassId), this.SerializationElement.Id, new Action<RolePlayerOrderChangedEventArgs>(OnChildMoved)); this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationClassReferencesAttributes.DomainClassId), true, this.SerializationElement.Id, new Action<ElementAddedEventArgs>(OnAttributeAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationClassReferencesAttributes.DomainClassId), true, this.SerializationElement.Id, new Action<ElementDeletedEventArgs>(OnAttributeRemoved)); this.EventManager.GetEvent<ModelRolePlayerMovedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationClassReferencesAttributes.DomainClassId), this.SerializationElement.Id, new Action<RolePlayerOrderChangedEventArgs>(OnAttributeMoved)); } }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="modelTreeView">Diagram tree view.</param> public DiagramViewModel(ViewModelStore viewModelStore, ModelContextViewModel modelContextVM, DiagramView diagramView) : base(viewModelStore) { this.diagramView = diagramView; this.modelContextVM = modelContextVM; this.contextMenuOperations = new Collection<MenuItemViewModel>(); this.selectedVMS = new Collection<object>(); this.rootNodeVMs = new ObservableCollection<DiagramClassViewModel>(); this.rootNodeVMsRO = new ReadOnlyObservableCollection<DiagramClassViewModel>(this.rootNodeVMs); if (diagramView != null) { foreach (DiagramClassView view in diagramView.DiagramClassViews) AddDiagramClassView(view); // subscribe this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(DiagramViewHasDiagramClassViews.DomainClassId), true, this.diagramView.Id, new Action<ElementAddedEventArgs>(OnDiagramClassViewAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(DiagramViewHasDiagramClassViews.DomainClassId), true, this.diagramView.Id, new Action<ElementDeletedEventArgs>(OnDiagramClassViewRemoved)); } addNewDiagramClassCommand = new DelegateCommand(AddNewDiagramClassCommand_Executed); addNewDiagramClassFromTemplateCommand = new DelegateCommand(AddNewDiagramClassFromTemplateCommand_Executed); addNewShapeClassCommand = new DelegateCommand(AddNewShapeClassCommand_Executed); addNewMappingRelationshipShapeClassCommand = new DelegateCommand(AddNewMappingRelationshipShapeClassCommand_Executed); addNewRelationshipShapeClassCommand = new DelegateCommand(AddNewRelationshipShapeClassCommand_Executed); addNewDomainPropertyCommand = new DelegateCommand(AddNewDomainPropertyCommand_Executed); unparentCommand = new DelegateCommand(UnparentCommand_Executed); reparentCommand = new DelegateCommand(ReparentCommand_Executed); moveUpCommand = new DelegateCommand(MoveUpCommand_Executed); moveDownCommand = new DelegateCommand(MoveDownCommand_Executed); deleteCommand = new DelegateCommand(DeleteCommand_Executed, DeleteCommand_CanExecute); viewPropertiesCommand = new DelegateCommand(ViewPropertiesCommand_Executed); addIncludedDDCCommand = new DelegateCommand(AddIncludedDDCCommand_Executed); addImportedDCCommand = new DelegateCommand(AddImportedDCCommand_Executed); showTemplateHelperCommand = new DelegateCommand(ShowTemplateHelperCommand_Executed); addNewDomainClassSEDCommand = new DelegateCommand(AddNewDomainClassSEDCommand_Executed); addNewDomainRLForRLShape = new DelegateCommand(AddNewDomainRLForRLShape_Executed); UpdateOperations(); this.EventManager.GetEvent<SelectionChangedEvent>().Subscribe(new Action<SelectionChangedEventArgs>(OnSelectionChanged)); }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="referenceRSNode">ReferenceRSNode.</param> /// <param name="parent">Parent.</param> public DomainRelationshipViewModel(ViewModelStore viewModelStore, DomainRelationship relationship, TreeNodeViewModel parent) : base(viewModelStore, relationship) { this.parentTreeNode = parent; if (relationship != null) { sourceRoleVM = new DomainRoleViewModel(this.ViewModelStore, relationship.Source, this); targetRoleVM = new DomainRoleViewModel(this.ViewModelStore, relationship.Target, this); } }
private static CategorizedAdvSelectableViewModel CreateCategorizedAdvSelectableVM(MetaModel model, string categoryName, ViewModelStore store, SelectionHelperTarget target) { List<CategorizedSelectableViewModel> vms = new List<CategorizedSelectableViewModel>(); foreach (BaseModelContext m in model.ModelContexts) { if (m is LibraryModelContext) { vms.Add(CreateCategorizedSelectableVM(m as LibraryModelContext, m.Name, store, target)); } } return new CategorizedAdvSelectableViewModel(store, categoryName, vms); }
/// <summary> /// Constructor. /// </summary> /// <param name="store"></param> /// <param name="optOperations"></param> /// <param name="opt"></param> public OptimizationMainViewModel(ViewModelStore store, MetamodelProcessor optOperations, List<BaseOptimization> opt) : base(store) { this.optOperations = optOperations; this.optList = opt; this.prevOptimizationCommand = new DelegateCommand(PrevOptimizationCommand_Executed, PrevOptimizationCommand_CanExecute); this.nextOptimizationCommand = new DelegateCommand(NextOptimizationCommand_Executed, NextOptimizationCommand_CanExecute); this.PrevOptimizationCommand.RaiseCanExecuteChanged(); this.NextOptimizationCommand.RaiseCanExecuteChanged(); this.UpdateCurrentOptimization(); }
private static CategorizedSelectableViewModel CreateCategorizedSelectableVM(LibraryModelContext model, string categoryName, ViewModelStore store, SelectionHelperTarget target) { List<SelectableViewModel> vms = new List<SelectableViewModel>(); if( (target & SelectionHelperTarget.DomainClass) > 0) foreach (DomainClass d in model.Classes) { vms.Add(new SelectableViewModel(store, d)); } if( (target & SelectionHelperTarget.EmbeddingRelationship) > 0 || (target & SelectionHelperTarget.ReferenceRelationship) > 0) foreach (DomainRelationship r in model.Relationships) { if( (target & SelectionHelperTarget.EmbeddingRelationship) > 0 && r is EmbeddingRelationship ) vms.Add(new SelectableViewModel(store, r)); if ((target & SelectionHelperTarget.ReferenceRelationship) > 0 && r is ReferenceRelationship) vms.Add(new SelectableViewModel(store, r)); } if ((target & SelectionHelperTarget.DiagramClass) > 0 || (target & SelectionHelperTarget.DiagramClassWithoutDerived) > 0) foreach(DiagramClass d in model.DiagramClasses) { if ((target & SelectionHelperTarget.DiagramClassWithoutDerived) > 0) { if (!(d is DesignerDiagramClass)) vms.Add(new SelectableViewModel(store, d)); } else vms.Add(new SelectableViewModel(store, d)); } if ((target & SelectionHelperTarget.ShapeClass) > 0 || (target & SelectionHelperTarget.RSShapeClass) > 0 || (target & SelectionHelperTarget.MappingShapeClass) > 0) foreach (DiagramClass d in model.DiagramClasses) foreach (PresentationElementClass p in d.PresentationElements) { if( p is ShapeClass && (target & SelectionHelperTarget.ShapeClass) > 0 ) vms.Add(new SelectableViewModel(store, p)); if (p is RelationshipShapeClass && (target & SelectionHelperTarget.RSShapeClass) > 0) vms.Add(new SelectableViewModel(store, p)); if (p is MappingRelationshipShapeClass && (target & SelectionHelperTarget.MappingShapeClass) > 0) vms.Add(new SelectableViewModel(store, p)); } vms.Sort(CompareByName); return new CategorizedSelectableViewModel(store, categoryName, vms); }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="diagramClass">Element to be hosted by this view model.</param> public DiagramClassViewModel(ViewModelStore viewModelStore, DiagramClassView diagramClassView, DiagramViewModel parent) : base(viewModelStore, diagramClassView.DiagramClass) { this.diagramClassView = diagramClassView; this.parent = parent; this.rootNodeVMs = new ObservableCollection<RootDiagramNodeViewModel>(); this.rootNodeVMsRO = new ReadOnlyObservableCollection<RootDiagramNodeViewModel>(this.rootNodeVMs); this.includedDCVMs = new ObservableCollection<IncludedDiagramClassViewModel>(); this.includedDCVMsRO = new ReadOnlyObservableCollection<IncludedDiagramClassViewModel>(includedDCVMs); this.importedDCCVMs = new ObservableCollection<ImportedDiagramClassViewModel>(); this.importedDCCVMsRO = new ReadOnlyObservableCollection<ImportedDiagramClassViewModel>(importedDCCVMs); if (this.DiagramClassView != null) { this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.DiagramClassView.Id, new Action<ElementPropertyChangedEventArgs>(OnElementPropertyChanged)); if (this.DiagramClassView.DiagramClass != null) this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.DiagramClassView.DiagramClass.Id, new Action<ElementPropertyChangedEventArgs>(OnElementPropertyChanged)); this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(DiagramClassViewHasRootDiagramNodes.DomainClassId), true, this.DiagramClassView.Id, new Action<ElementAddedEventArgs>(OnRootDiagramNodeAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(DiagramClassViewHasRootDiagramNodes.DomainClassId), true, this.DiagramClassView.Id, new Action<ElementDeletedEventArgs>(OnRootDiagramNodeRemoved)); this.EventManager.GetEvent<ModelRolePlayerMovedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(DiagramClassViewHasRootDiagramNodes.DomainClassId), this.DiagramClassView.Id, new Action<RolePlayerOrderChangedEventArgs>(OnRootDiagramNodeMoved)); this.EventManager.GetEvent<ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(DiagramClassViewHasRootDiagramNodes.DiagramClassViewDomainRoleId), new Action<RolePlayerChangedEventArgs>(OnRootDiagramNodeChanged)); } if (this.GetHostedElement() is DesignerDiagramClass) { this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(DesignerDiagramClassReferencesIncludedDiagramClasses.DomainClassId), true, this.GetHostedElement().Id, new Action<ElementAddedEventArgs>(OnIncludedDDCAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(DesignerDiagramClassReferencesIncludedDiagramClasses.DomainClassId), true, this.GetHostedElement().Id, new Action<ElementDeletedEventArgs>(OnIncludedDDCRemoved)); this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(DesignerDiagramClassReferencesImportedDiagramClasses.DomainClassId), true, this.GetHostedElement().Id, new Action<ElementAddedEventArgs>(OnImportedDCAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(DesignerDiagramClassReferencesImportedDiagramClasses.DomainClassId), true, this.GetHostedElement().Id, new Action<ElementDeletedEventArgs>(OnImportedDCRemoved)); } }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="modelTreeView">Domain model tree view.</param> public ModelTreeViewModel(ViewModelStore viewModelStore, ModelContextViewModel modelContextVM, DomainModelTreeView modelTreeView) : base(viewModelStore) { this.rootNodeVMs = new ObservableCollection<RootNodeViewModel>(); this.rootNodeVMsRO = new ReadOnlyObservableCollection<RootNodeViewModel>(rootNodeVMs); this.modelContextVM = modelContextVM; this.modelTreeView = modelTreeView; this.selectedVMS = new Collection<object>(); this.contextMenuOperations = new Collection<MenuItemViewModel>(); addNewDomainPropertyCommand = new DelegateCommand(AddNewDomainPropertyCommand_Executed); addNewDomainClassCommand = new DelegateCommand(AddNewDomainClassCommand_Executed); addNewEmbeddingRSCommand = new DelegateCommand(AddNewEmbeddingRSCommand_Executed); addNewEmbeddingRSToExistantCommand = new DelegateCommand(AddNewEmbeddingRSToExistantCommand_Executed); addNewReferenceRSCommand = new DelegateCommand(AddNewReferenceRSCommand_Executed); addNewReferenceRSToRSCommand = new DelegateCommand(AddNewReferenceRSToRSCommand_Executed); addNewInheritanceRSCommand = new DelegateCommand(AddNewInheritanceRSCommand_Executed); addNewDerivedElementCommand = new DelegateCommand(AddNewDerivedElementCommand_Executed); deleteCommand = new DelegateCommand(DeleteCommand_Executed, DeleteCommand_CanExecute); showTemplateHelperCommand = new DelegateCommand(ShowTemplateHelperCommand_Executed); /* copyCommand = new DelegateCommand(CopyCommand_Executed, CopyCommand_CanExecute); pasteCommand = new DelegateCommand(PasteCommand_Executed, PasteCommand_CanExecute); */ bringTreeHereCommand = new DelegateCommand(BringTreeHereCommand_Executed); splitTreeCommand = new DelegateCommand(SplitTreeCommand_Executed); moveUpCommand = new DelegateCommand(MoveUpCommand_Executed); moveDownCommand = new DelegateCommand(MoveDownCommand_Executed); viewPropertiesCommand = new DelegateCommand(ViewPropertiesCommand_Executed); addMappingToNewRelShapeClassCommand = new DelegateCommand(AddMappingToNewRelShapeClassCommand_Executed); addMappingToExtRelShapeClassCommand = new DelegateCommand(AddMappingToExtRelShapeClassCommand_Executed); addMappingToNewShapeClassCommand = new DelegateCommand(AddMappingToNewShapeClassCommand_Executed); addMappingToExtShapeClassCommand = new DelegateCommand(AddMappingToExtShapeClassCommand_Executed); addMappingToNewMappingShapeClassCommand = new DelegateCommand(AddMappingToNewMappingShapeClassCommand_Executed); addMappingToExtMappingShapeClassCommand = new DelegateCommand(AddMappingToExtMappingShapeClassCommand_Executed); UpdateOperations(); foreach (RootNode n in modelTreeView.RootNodes) this.AddRootNode(n); this.EventManager.GetEvent<SelectionChangedEvent>().Subscribe(new Action<SelectionChangedEventArgs>(OnSelectionChanged)); Subscribe(); }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="serializedDomainRole">SerializedDomainRole.</param> /// <param name="referencedElement">Element that is referenced by the serialization element. Can be null.</param> public SerializedDomainRoleViewModel(ViewModelStore viewModelStore, DomainRole domainRole, DomainRelationship referencedElement, SerializedRelationshipViewModel parentVM) : base(viewModelStore, null, referencedElement) { this.parentVM = parentVM; this.domainRole = domainRole; if (domainRole != null) { this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.domainRole.Id, new Action<ElementPropertyChangedEventArgs>(OnSerializedRolePropertyChanged)); if (this.domainRole.RolePlayer != null) this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.domainRole.RolePlayer.Id, new Action<ElementPropertyChangedEventArgs>(OnSerializedRolePropertyChanged)); } }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="modelTreeView">Domain model tree view.</param> /// <param name="parent">Parent node.</param> protected TreeNodeViewModel(ViewModelStore viewModelStore, TreeNode treeNode, TreeNodeViewModel parent) : base(viewModelStore, treeNode.DomainElement) { this.treeNode = treeNode; this.parentTreeNode = parent; this.embeddingRSNodeVMs = new ObservableCollection<EmbeddingRSNodeViewModel>(); this.embeddingRSNodeVMsRO = new ReadOnlyObservableCollection<EmbeddingRSNodeViewModel>(embeddingRSNodeVMs); this.inheritanceNodeVMs = new ObservableCollection<InheritanceNodeViewModel>(); this.inheritanceNodeVMsRO = new ReadOnlyObservableCollection<InheritanceNodeViewModel>(inheritanceNodeVMs); this.referenceRSNodeVMs = new ObservableCollection<ReferenceRSNodeViewModel>(); this.referenceRSNodeVMsRO = new ReadOnlyObservableCollection<ReferenceRSNodeViewModel>(referenceRSNodeVMs); this.shapeClassNodeVMs = new ObservableCollection<ShapeClassNodeViewModel>(); this.shapeClassNodeVMsRO = new ReadOnlyObservableCollection<ShapeClassNodeViewModel>(shapeClassNodeVMs); this.collapseExpandEmbeddingCommand = new DelegateCommand(CollapseExpandEmbeddingCommand_Executed); this.collapseExpandReferencingCommand = new DelegateCommand(CollapseExpandReferencingCommand_Executed); this.collapseExpandInheritingCommand = new DelegateCommand(CollapseExpandInheritingCommand_Executed); this.collapseExpandClassShapeMappingCommand = new DelegateCommand(CollapseExpandClassShapeMappingCommand_Executed); if (this.TreeNode != null) { foreach (EmbeddingRSNode node in this.TreeNode.EmbeddingRSNodes) if (node != null) AddEmbeddingRSNode(node); foreach (ReferenceRSNode node in this.TreeNode.ReferenceRSNodes) if (node != null) AddReferenceRSNode(node); foreach (InheritanceNode node in this.TreeNode.InheritanceNodes) if (node != null) AddInheritanceNode(node); foreach (ShapeClassNode node in this.TreeNode.ShapeClassNodes) if (node != null) AddShapeClassNode(node); Subscribe(); } }
private static void CreateCategorizedVM(MetaModel model, ViewModelStore store, SelectionHelperTarget target, List<MetaModel> handledMetaModels, List<CategorizedAdvSelectableViewModel> modelCategoryVMs) { if (!handledMetaModels.Contains(model)) { CategorizedAdvSelectableViewModel modelCategoryVM = CreateCategorizedAdvSelectableVM(model, model.Name, store, target); modelCategoryVMs.Add(modelCategoryVM); handledMetaModels.Add(model); // imported models foreach (MetaModelLibrary library in model.MetaModelLibraries) if (library.ImportedLibrary != null) if (library.ImportedLibrary is MetaModel) CreateCategorizedVM(library.ImportedLibrary as MetaModel, store, target, handledMetaModels, modelCategoryVMs); } else return; }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="embeddingRSNode">EmbeddingRSNode.</param> /// <param name="parent">Parent.</param> public EmbeddingRSNodeViewModel(ViewModelStore viewModelStore, EmbeddingRSNode embeddingRSNode, TreeNodeViewModel parent) : base(viewModelStore, embeddingRSNode.Relationship, parent) { this.embeddingRSNode = embeddingRSNode; this.embeddingNodeVMs = new ObservableCollection<EmbeddingNodeViewModel>(); this.embeddingNodeVMsRO = new ReadOnlyObservableCollection<EmbeddingNodeViewModel>(embeddingNodeVMs); if (embeddingRSNode != null) { if (embeddingRSNode.EmbeddingNode != null) { AddEmbeddingNode(embeddingRSNode.EmbeddingNode); } Subscribe(); } }
/// <summary> /// Constuctor. /// </summary> /// <param name="viewModelStore">The store this view model belongs to.</param> /// <param name="diagramClass">Element to be hosted by this view model.</param> public ModalDiagramViewModel(ViewModelStore viewModelStore, DiagramClassView diagramClassView, DiagramViewModel parent) : base(viewModelStore, diagramClassView, parent) { ModalDiagram diagramClass = diagramClassView.DiagramClass as ModalDiagram; if (diagramClass.DomainClass != null) { this.ReferenceVM = new BaseModelElementViewModel(this.ViewModelStore, diagramClass, true); } this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(ModalDiagramReferencesDomainClass.DomainClassId), true, diagramClass.Id, new Action<ElementAddedEventArgs>(OnReferenceAdded)); this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(ModalDiagramReferencesDomainClass.DomainClassId), true, diagramClass.Id, new Action<ElementDeletedEventArgs>(OnReferenceRemoved)); this.EventManager.GetEvent<ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(ModalDiagramReferencesDomainClass.DomainClassDomainRoleId), new Action<RolePlayerChangedEventArgs>(OnReferenceChanged)); }