/// <summary> /// Selection helper method. This takes the existing selection in the /// context and creates a new selection that contains the toggled /// state of the item. If the item is to be /// added to the selection, it is added as the primary selection. /// </summary> /// <param name="context">The editing context to apply this selection change to.</param> /// <param name="itemToToggle">The item to toggle selection for.</param> /// <returns>A Selection object that contains the new selection.</returns> /// <exception cref="ArgumentNullException">If context or itemToToggle is null.</exception> internal static T Toggle <T>(EditingContext context, EFObject itemToToggle) where T : Selection { if (context == null) { throw new ArgumentNullException("context"); } if (itemToToggle == null) { throw new ArgumentNullException("itemToToggle"); } var existing = context.Items.GetValue <T>(); // Is the item already in the selection? If so, remove it. // If not, add it to the beginning. var list = new List <EFObject>(existing.SelectedObjects); if (list.Contains(itemToToggle)) { list.Remove(itemToToggle); } else { list.Insert(0, itemToToggle); } var selection = Activator.CreateInstance <T>(); selection.SetSelectedObjects(list); context.Items.SetValue(selection); return(selection); }
internal ModelElement GetExisting(EFObject obj) { ModelElement result; _modelToViewModel.TryGetValue(obj, out result); return(result); }
/// <summary> /// Retrieve the root "Schema" node for current node. If there is no root mapping node, this will return null. /// </summary> /// <returns></returns> internal static XNamespace GetRootNamespace(EFObject node) { var currNode = node; EFRuntimeModelRoot runtimeModel = null; EFDesignerInfoRoot designerInfo = null; XNamespace ns = null; while (currNode != null) { runtimeModel = currNode as EFRuntimeModelRoot; designerInfo = currNode as EFDesignerInfoRoot; if (runtimeModel != null) { ns = runtimeModel.XNamespace; break; } else if (designerInfo != null) { ns = designerInfo.XNamespace; break; } else { currNode = currNode.Parent; } } return ns; }
internal void RecordModelChange( EfiChange.EfiChangeType changeType, EFObject changed, string property, object oldValue, object newValue) { switch (changeType) { case EfiChange.EfiChangeType.Create: _creates.Add(new EfiChange(changeType, changed)); break; case EfiChange.EfiChangeType.Delete: _deletes.Add(new EfiChange(changeType, changed)); break; case EfiChange.EfiChangeType.Update: EfiChange change = null; if (_updates.ContainsKey(changed)) { change = _updates[changed]; } else { change = new EfiChange(changeType, changed); _updates[changed] = change; } change.RecordModelChange(property, oldValue, newValue); break; } }
/// <summary> /// Selection helper method. This takes the existing selection in the /// context and creates a new selection that contains the original /// selection and the itemToAdd. If itemToAdd is already in the /// original selection it is promoted to the primary selection. /// </summary> /// <param name="context">The editing context to apply this selection change to.</param> /// <param name="itemToAdd">The item to add to the selection.</param> /// <returns>A Selection object that contains the new selection.</returns> /// <exception cref="ArgumentNullException">If context or itemToAdd is null.</exception> internal static T Union <T>(EditingContext context, EFObject itemToAdd) where T : Selection { if (context == null) { throw new ArgumentNullException("context"); } if (itemToAdd == null) { throw new ArgumentNullException("itemToAdd"); } var existing = context.Items.GetValue <T>(); // short cut if we're already in the right state. if (existing.PrimarySelection == itemToAdd) { return(existing); } // Is the item already in the selection? If not, add it. var list = new List <EFObject>(existing.SelectedObjects); if (list.Contains(itemToAdd)) { list.Remove(itemToAdd); } list.Insert(0, itemToAdd); var selection = Activator.CreateInstance <T>(); selection.SetSelectedObjects(list); context.Items.SetValue(selection); return(selection); }
/// <summary> /// Selection helper method. This sets itemToSelect into the selection. /// Any existing items are deselected. /// </summary> /// <param name="context">The editing context to apply this selection change to.</param> /// <param name="itemToSelect">The item to select.</param> /// <returns>A Selection object that contains the new selection.</returns> /// <exception cref="ArgumentNullException">If context or itemToSelect is null.</exception> internal static T SelectOnly <T>(EditingContext context, EFObject itemToSelect) where T : Selection { if (context == null) { throw new ArgumentNullException("context"); } if (itemToSelect == null) { throw new ArgumentNullException("itemToSelect"); } // Check to see if only this object is selected. If so, bail. var existing = context.Items.GetValue <T>(); if (existing.PrimarySelection == itemToSelect) { var en = existing.SelectedObjects.GetEnumerator(); en.MoveNext(); if (!en.MoveNext()) { return(existing); } } var selection = Activator.CreateInstance <T>(); selection.SetSelectedObjects(itemToSelect); context.Items.SetValue(selection); return(selection); }
internal static void ScheduleChildAntiDependenciesForRebinding(CommandProcessorContext cpc, EFObject efObject) { // identify any binding that was referencing this symbol, and add it to the list of things to rebind. var visitor = new AntiDependencyCollectorVisitor(); visitor.Traverse(efObject); ScheduleBindingsForRebind(cpc, visitor.AntiDependencyBindings); }
/// <summary> /// This method makes sure that: /// 1. Any given item is not duplicated in the list /// 2. If the newDeleted item's parent is already in the list, don't add it /// 3. If any children of newDeleted are already in the list, remove the child item /// This greatly optimizes the actually CleanUp() process. /// </summary> /// <param name="newDeleted"></param> private void AddToDeleteList(EFObject newDeleted) { // if newDeleted is already there, just return if (_itemsToDelete.Contains(newDeleted)) { return; } // don't add newDeleted if any of its parents are already being deleted var container = newDeleted.Parent; while (container != null) { if (_itemsToDelete.Contains(container)) { return; } container = container.Parent; } // if the newDeleted item is the parent of an existing item // remove the child item and just add the parent below RemoveChildrenOfNewDeleted(newDeleted as EFContainer); // add the item _itemsToDelete.Add(newDeleted); }
internal void RecordModelChange( EfiChange.EfiChangeType changeType, EFObject changed, string property, object oldValue, object newValue) { switch (changeType) { case EfiChange.EfiChangeType.Create: _creates.Add(new EfiChange(changeType, changed)); break; case EfiChange.EfiChangeType.Delete: _deletes.Add(new EfiChange(changeType, changed)); break; case EfiChange.EfiChangeType.Update: EfiChange change = null; if (_updates.ContainsKey(changed)) { change = _updates[changed]; } else { change = new EfiChange(changeType, changed); _updates[changed] = change; } change.RecordModelChange(property, oldValue, newValue); break; } }
private void CheckAll(EFObject obj) { CheckEntityType(obj); CheckAssociation(obj); CheckEntityModel(obj); CheckComplexType(obj); }
/// <summary> /// This method will make an AttributePath for a given an EFObject. /// </summary> private static AttributePath MakeAttributePathFromEFObject(EFObject efobject) { var attributePath = new AttributePath(); var curr = efobject.XObject; while (curr != null) { if (curr.NodeType == XmlNodeType.Document) { var doc = (XDocument)curr; attributePath.PushFront(doc.Root.Name.LocalName, doc.Root.Name.Namespace.NamespaceName, true); } else if (curr.NodeType == XmlNodeType.Attribute) { var attr = (XAttribute)curr; attributePath.PushFront(attr.Name.LocalName, attr.Name.Namespace.NamespaceName, false); } else if (curr.NodeType == XmlNodeType.Element) { var el = (XElement)curr; attributePath.PushFront(el.Name.LocalName, el.Name.Namespace.NamespaceName, true); } else { Debug.Fail("Unexpected XObject type is neither an attribute nor an element"); return(null); } curr = curr.Parent; } return(attributePath); }
internal static MappingViewModel CreateViewModel(EditingContext ctx, EFObject selection) { // clear out the xref so its clean for this new view model var xref = ModelToMappingModelXRef.GetModelToMappingModelXRef(ctx); xref.Clear(); // we might be creating a view model for an entity or an association or a FunctionImport var entityType = selection as EntityType; var association = selection as Association; var fim = selection as FunctionImportMapping; // create the view model root MappingEFElement root = null; if (entityType != null) { root = ModelToMappingModelXRef.GetNewOrExisting(ctx, entityType, null); } else if (association != null) { root = ModelToMappingModelXRef.GetNewOrExisting(ctx, association, null); } else if (fim != null) { root = ModelToMappingModelXRef.GetNewOrExisting(ctx, fim, null); } else { throw new ArgumentException("selection"); } return new MappingViewModel(ctx, root); }
internal static void RefactorRenameElement(EFObject objectToRefactor, string newName = null, bool showPreview = true) { if (objectToRefactor != null && objectToRefactor.Artifact != null) { var namedObject = objectToRefactor as EFNormalizableItem; if (namedObject != null) { // If the API call did not supply a new name for the object, bring up the dialog for the user to input a name if (newName == null) { var dialog = new RefactorRenameDialog(namedObject); if (dialog.ShowModal() == true) { newName = dialog.NewName; if (dialog.ShowPreview.HasValue) { showPreview = dialog.ShowPreview.Value; } } } if (newName != null) { RefactorRenameElementInDesignerOnly(namedObject, newName, showPreview); } } } }
private bool CheckForMissingAnnotations(EFObject efObject) { if (_checkAnnotations) { var miaEFobject = ModelItemAnnotation.GetModelItem(efObject.XObject); var isArtifact = efObject is EFArtifact; if (miaEFobject == null && !isArtifact) { if (!_noMIAList.Contains(efObject.XObject)) { _noMIAList.Add(efObject.XObject); } return(true); } // Check for incorrect/stale annotations if (miaEFobject != efObject && !isArtifact && !IsValidGhostNode(efObject)) { if (!_incorrectMIAList.ContainsKey(efObject.XObject)) { _incorrectMIAList.Add(efObject.XObject, miaEFobject); } return(true); } } return(false); }
internal static MappingViewModel CreateViewModel(EditingContext ctx, EFObject selection) { // clear out the xref so its clean for this new view model var xref = ModelToMappingModelXRef.GetModelToMappingModelXRef(ctx); xref.Clear(); // we might be creating a view model for an entity or an association or a FunctionImport var entityType = selection as EntityType; var association = selection as Association; var fim = selection as FunctionImportMapping; // create the view model root MappingEFElement root = null; if (entityType != null) { root = ModelToMappingModelXRef.GetNewOrExisting(ctx, entityType, null); } else if (association != null) { root = ModelToMappingModelXRef.GetNewOrExisting(ctx, association, null); } else if (fim != null) { root = ModelToMappingModelXRef.GetNewOrExisting(ctx, fim, null); } else { throw new ArgumentException("selection"); } return(new MappingViewModel(ctx, root)); }
private bool CheckForNoXObject(EFObject efObject) { if (_checkXObject && efObject.XObject == null) { // some EFAttributes are not tied to XAttributes var efAttribute = efObject as EFAttribute; var parentElement = efObject.Parent as EFElement; if (efAttribute != null && parentElement != null) { var xattr = efAttribute.Namespace != null ? parentElement.GetAttribute(efObject.EFTypeName, efAttribute.Namespace.NamespaceName) : parentElement.GetAttribute(efObject.EFTypeName); if (xattr == null) { return(true); } } if (!_noXObjectList.Contains(efObject)) { _noXObjectList.Add(efObject); } return(true); } return(false); }
private static ModelElement CreateModelElementForEFObjectType(EFObject obj, Partition partition) { ModelElement modelElement = null; var t = obj.GetType(); if (t == typeof(ConceptualEntityModel)) { modelElement = new EntityDesignerViewModel(partition); } else if (t == typeof(ConceptualEntityType)) { modelElement = new EntityType(partition); } else if (t == typeof(ConceptualProperty)) { modelElement = new ScalarProperty(partition); } else if (t == typeof(ComplexConceptualProperty)) { modelElement = new ComplexProperty(partition); } else if (t == typeof(Association)) { modelElement = new ViewModel.Association(partition); } else if (t == typeof(EntityTypeBaseType)) { modelElement = new Inheritance(partition); } else if (t == typeof(NavigationProperty)) { modelElement = new ViewModel.NavigationProperty(partition); } return modelElement; }
internal static void RefactorRenameElement(EFObject objectToRefactor, string newName = null, bool showPreview = true) { if (objectToRefactor != null && objectToRefactor.Artifact != null) { var namedObject = objectToRefactor as EFNormalizableItem; if (namedObject != null) { // If the API call did not supply a new name for the object, bring up the dialog for the user to input a name if (newName == null) { var dialog = new RefactorRenameDialog(namedObject); if (dialog.ShowModal() == true) { newName = dialog.NewName; if (dialog.ShowPreview.HasValue) { showPreview = dialog.ShowPreview.Value; } } } if (newName != null) { RefactorRenameElementInDesignerOnly(namedObject, newName, showPreview); } } } }
internal override DslModeling.ModelElement SynchronizeSingleDslModelElement( DslModeling.ModelElement parentViewModel, EFObject modelElement) { var t = modelElement.GetType(); if (t == typeof(ConceptualEntityType)) { return(TranslateEntityType(parentViewModel as EntityDesignerViewModel, modelElement as ConceptualEntityType)); } else if (t == typeof(EntityTypeBaseType)) { return(TranslateBaseType(parentViewModel as EntityDesignerViewModel, (modelElement).Parent as ConceptualEntityType)); } else if (t == typeof(ModelNavigationProperty)) { return(TranslateNavigationProperty(parentViewModel as ViewModelEntityType, modelElement as ModelNavigationProperty)); } else if (t == typeof(ComplexConceptualProperty) || t == typeof(ConceptualProperty)) { return(TranslateProperty(parentViewModel as ViewModelEntityType, modelElement as ModelProperty)); } else if (t == typeof(ModelAssociation)) { return(TranslateAssociation(parentViewModel as EntityDesignerViewModel, modelElement as ModelAssociation)); } else if (t == typeof(DesignerModel.Diagram)) { return(TranslateDiagramValues(parentViewModel as EntityDesignerViewModel, modelElement as DesignerModel.Diagram)); } Debug.Assert(false, "modelElement with type= " + t.Name + " is not supported"); return(null); }
internal static void NavigateTo(EFObject efobject) { if (efobject.RuntimeModelRoot() == null) { // nothing to navigate to, so just return; return; } if (efobject.RuntimeModelRoot() is StorageEntityModel) { // s-space object, so just return; return; } var selectionService = Services.DslMonitorSelectionService; Debug.Assert(selectionService != null, "Could not retrieve IMonitorSelectionService from Escher package."); var foundDSLElementMatchInDiagram = false; if (selectionService != null) { var singleDiagramDocView = selectionService.CurrentDocumentView as SingleDiagramDocView; if (singleDiagramDocView != null) { foundDSLElementMatchInDiagram = NavigateToDSLNodeInDiagram( singleDiagramDocView.Diagram as EntityDesignerDiagram, efobject); if (foundDSLElementMatchInDiagram) { // The code below is added to ensure that the right doc-view is shown and activated. singleDiagramDocView.Frame.Show(); return; } } } // Retrieves the doc data for the efobject. var docdata = VSHelpers.GetDocData(Services.ServiceProvider, efobject.Uri.LocalPath) as ModelingDocData; Debug.Assert(docdata != null, "Could not find get doc data for artifact with URI:" + efobject.Uri.LocalPath); if (docdata != null) { foreach (var docView in docdata.DocViews) { var singleDiagramDocView = docView as SingleDiagramDocView; Debug.Assert( singleDiagramDocView != null, "Why the doc view is not type of SingleDiagramDocView? Actual type:" + docView.GetType().Name); if (docView != null) { foundDSLElementMatchInDiagram = NavigateToDSLNodeInDiagram( singleDiagramDocView.Diagram as EntityDesignerDiagram, efobject); if (foundDSLElementMatchInDiagram) { // The code below is added to ensure that the right doc-view is shown and activated. singleDiagramDocView.Frame.Show(); return; } } } } }
internal void Add(EFObject obj, ModelElement viewElement, EditingContext context) { if (_globalMapModelAndViewModel.ContainsKey(viewElement.Partition) == false) { _globalMapModelAndViewModel[viewElement.Partition] = new ModelToDesignerModelXRefItem(); } _globalMapModelAndViewModel[viewElement.Partition].Add(obj, viewElement, context); }
internal ModelElement GetExisting(EFObject obj, Partition partition) { if (_globalMapModelAndViewModel.ContainsKey(partition)) { return(_globalMapModelAndViewModel[partition].GetExisting(obj)); } return(null); }
internal override void Initialize(EFObject obj, EditingContext editingContext, bool runningInVS) { base.Initialize(obj, editingContext, runningInVS); if (obj != null) { LoadDesignerInfoAndDescriptors(editingContext, obj.Artifact); } }
internal void Remove(EFObject obj, ModelElement viewElement) { Debug.Assert( _globalMapModelAndViewModel.ContainsKey(viewElement.Partition), "There is no modelToViewModel map for the partition"); if (_globalMapModelAndViewModel.ContainsKey(viewElement.Partition)) { _globalMapModelAndViewModel[viewElement.Partition].Remove(obj, viewElement); } }
internal void Remove(EFObject efObject) { ModelElement viewElement; if (_modelToViewModel.TryGetValue(efObject, out viewElement)) { Remove(efObject, viewElement); } }
internal override void Initialize(EFObject obj, EditingContext editingContext, bool runningInVS) { _attribute = obj as TEFAttribute; _editingContext = editingContext; _runningInVS = runningInVS; // now perform any initialization on derived types OnTypeDescriptorInitialize(); }
internal void Remove(EFObject efObject) { ModelElement viewElement; if (_modelToViewModel.TryGetValue(efObject, out viewElement)) { Remove(efObject, viewElement); } }
/// <summary> /// Returns the top most ComplexProperty that this ScalarProperty lives in (null if the parent isn't a ComplexProperty) /// </summary> /// <returns></returns> internal ComplexProperty GetTopMostComplexProperty() { EFObject efObject = this; while (efObject.Parent is ComplexProperty) { efObject = efObject.Parent; } return(efObject as ComplexProperty); }
private static void Main(string[] args) { Mapper.CreateMap <EFObject, DTOObject>(). ForMember(dtoo => dtoo.DS, opt => opt.MapFrom(efo => efo.D.ToString("g"))); var fromDB = new EFObject() { D = DateTime.Now }; var toDTO = Mapper.Map <EFObject, DTOObject>(fromDB); }
internal EFRenameContributorInput(EFObject objectToBeRenamed, string newName, string oldName) { ArgumentValidation.CheckForNullReference(objectToBeRenamed, "objectToBeRenamed"); ArgumentValidation.CheckForNullReference(newName, "newName"); ArgumentValidation.CheckForNullReference(oldName, "oldName"); _objectToBeRenamed = objectToBeRenamed; _oldName = oldName; _newName = newName; }
private void CheckComplexType(EFObject obj) { var complexType = obj as ComplexType; if (complexType != null) { CheckForCircularComplexTypeDefinition(complexType); CheckForEnumPropertiesWithStoreGeneratedPattern(complexType); } }
internal EFRenameContributorInput(EFObject objectToBeRenamed, string newName, string oldName) { ArgumentValidation.CheckForNullReference(objectToBeRenamed, "objectToBeRenamed"); ArgumentValidation.CheckForNullReference(newName, "newName"); ArgumentValidation.CheckForNullReference(oldName, "oldName"); _objectToBeRenamed = objectToBeRenamed; _oldName = oldName; _newName = newName; }
private void CheckAssociation(EFObject obj) { var a = obj as Association; if (a != null) { CheckForAssociationWithoutAssociationSet(a); CheckForUnmappedAssociation(a); CheckAssociationForUnmappedEntityTypeKeys(a); } }
private void CheckEntityType(EFObject obj) { var et = obj as EntityType; if (et != null) { CheckForEntityTypesWithoutEntitySets(et); CheckForMultipleEntitySetsPerType(et); CheckConceptualEntityType(et); } }
internal static IList <ModelElement> GetExisting(EditingContext context, EFObject obj) { IList <ModelElement> result; var xref = GetModelToDesignerModelXRef(context); result = xref.GetExisting(obj); Debug.Assert(result != null); return(result); }
internal ErrorInfo(Severity severity, string message, EFObject item, int errorCode, ErrorClass errorClass) { Debug.Assert(item != null, "item != null"); _severity = severity; // prefix the error code in front of the error message. This is here to help identify runtime errors that cause safe-mode _message = String.Format(CultureInfo.CurrentCulture, Resources.Error_Message_With_Error_Code_Prefix, errorCode, message); _item = item; _errorCode = errorCode; _errorClass = errorClass; }
internal static void SetModelItem(XObject xobject, EFObject efobject) { if (xobject.Annotation <EFObject>() == null) { xobject.AddAnnotation(efobject); } else { xobject.RemoveAnnotations <EFObject>(); xobject.AddAnnotation(efobject); } }
internal static void SetModelItem(XObject xobject, EFObject efobject) { if (xobject.Annotation<EFObject>() == null) { xobject.AddAnnotation(efobject); } else { xobject.RemoveAnnotations<EFObject>(); xobject.AddAnnotation(efobject); } }
internal void UpdateSelection() { var newSelection = new HashSet <EFObject>(); if (SelectedModelItem != null && TreeControl.CurrentColumn < TreeControl.Columns.Length && TreeControl.Columns[TreeControl.CurrentColumn] != null) { // use the current column index to find what type of column we have var currentColumnType = TreeControl.Columns[TreeControl.CurrentColumn].GetType(); // we have to find the "descriptable" EFElements for the MappingEFElements here EFObject modelItemForDescriptor = null; if (SelectedModelItem is ScalarProperty) { var scalarProperty = SelectedModelItem as ScalarProperty; if (currentColumnType.IsAssignableFrom(typeof(ValueColumn)) || currentColumnType.IsAssignableFrom(typeof(PropertyColumn))) { modelItemForDescriptor = scalarProperty.Name.Target; } else if (currentColumnType.IsAssignableFrom(typeof(ColumnNameColumn))) { modelItemForDescriptor = scalarProperty.ColumnName.Target; } } else if (SelectedModelItem is FunctionScalarProperty) { var functionScalarProperty = SelectedModelItem as FunctionScalarProperty; if (currentColumnType.IsAssignableFrom(typeof(PropertyColumn))) { modelItemForDescriptor = functionScalarProperty.Name.Target; } else if (currentColumnType.IsAssignableFrom(typeof(ParameterColumn))) { modelItemForDescriptor = functionScalarProperty.ParameterName.Target; } } // if we were able to find a corresponding descriptable EFElement (if we allow the property window to // display the properties) then add the EFElement to a new MappingDetailsSelection and update the context if (modelItemForDescriptor != null) { newSelection.Add(modelItemForDescriptor); } } if (_editingContext != null && _editingContext.Items != null) { _editingContext.Items.SetValue(new MappingDetailsSelection(newSelection)); } }
private static T GetFirstAntiDependencyOfType <T>(EFObject obj) where T : EFObject { var antiDeps = obj.GetAntiDependenciesOfType <T>(); if (antiDeps != null) { foreach (var t in antiDeps) { return(t); } } return(null); }
private ErrorInfo(Severity severity, string message, EFObject item, string itemPath, int errorCode, ErrorClass errorClass) { Debug.Assert(item == null ^ itemPath == null, "item and itemPath are mutually exclusive"); _severity = severity; _item = item; _itemPath = itemPath; // prefix the error code in front of the error message. This is here to help identify runtime errors that cause safe-mode _message = String.Format(CultureInfo.CurrentCulture, Resources.Error_Message_With_Error_Code_Prefix, errorCode, message); _item = item; _errorCode = errorCode; _errorClass = errorClass; }
internal void Add(EFObject obj, ModelElement viewElement, EditingContext context) { var viewModel = viewElement as EntityDesignerViewModel; if (viewModel != null) { viewModel.EditingContext = context; } Remove(obj); Remove(viewElement); _modelToViewModel.Add(obj, viewElement); _viewModelToModel.Add(viewElement, obj); }
internal override void Initialize(EFObject obj, EditingContext editingContext, bool runningInVS) { _entityTypeShape = obj as EntityTypeShape; Debug.Assert(_entityTypeShape != null, "EFObject is null or is not a type of EntityTypeShape."); if (_entityTypeShape != null) { var entityType = _entityTypeShape.EntityType.Target; Debug.Assert(entityType != null, "EntityTypeShape does not contain instance of an entity type."); if (entityType != null) { base.Initialize(entityType, editingContext, runningInVS); } } }
private static ExplorerTreeViewItem GetTreeViewItemForEFObject(EFObject efobject, ExplorerFrame explorerFrame) { var treeViewItem = explorerFrame.ExplorerTreeRoot; if (null != efobject && !(efobject is EFArtifact)) { var entityDesignArtifact = efobject.Artifact.ArtifactSet.GetEntityDesignArtifact(); var editingContext = PackageManager.Package.DocumentFrameMgr.EditingContextManager.GetNewOrExistingContext(entityDesignArtifact.Uri); var element = explorerFrame.ExplorerViewModelHelper.GetExplorerEFElementForEFObject(editingContext, efobject); Debug.Assert(element != null, "Unable to find ExplorerEFElement for efobject of type " + efobject.GetType()); if (element != null) { treeViewItem = explorerFrame.GetTreeViewItem(element, true); } } return treeViewItem; }
internal static ModelElement CreateConnectorModelElementForEFObjectType(EFObject obj, ModelElement end1, ModelElement end2) { ModelElement modelElement = null; var t = obj.GetType(); var et1 = end1 as EntityType; var et2 = end2 as EntityType; if (t == typeof(Association)) { Debug.Assert(et1 != null && et2 != null, "Unexpected end type for Association model element"); modelElement = new ViewModel.Association(et1, et2); } else if (t == typeof(EntityTypeBaseType)) { Debug.Assert(et1 != null && et2 != null, "Unexpected end type for Inheritance model element"); modelElement = new Inheritance(et1, et2); } return modelElement; }
internal static XNamespace GetRootNamespace(EFObject node) { var currNode = node; EFDesignerInfoRoot model = null; XNamespace ns = null; while (currNode != null) { model = currNode as EFDesignerInfoRoot; if (model != null) { ns = model.XNamespace; break; } else { currNode = currNode.Parent; } } return ns; }
internal EfiChange(EfiChangeType changeType, EFObject changed) { _changeType = changeType; _changed = changed; _properties = new Dictionary<string, OldNewPair>(); }
private bool CheckForMissingAnnotations(EFObject efObject) { if (_checkAnnotations) { var miaEFobject = ModelItemAnnotation.GetModelItem(efObject.XObject); var isArtifact = efObject is EFArtifact; if (miaEFobject == null && !isArtifact) { if (!_noMIAList.Contains(efObject.XObject)) { _noMIAList.Add(efObject.XObject); } return true; } // Check for incorrect/stale annotations if (miaEFobject != efObject && !isArtifact && !IsValidGhostNode(efObject)) { if (!_incorrectMIAList.ContainsKey(efObject.XObject)) { _incorrectMIAList.Add(efObject.XObject, miaEFobject); } return true; } } return false; }
private bool CheckForNoXObject(EFObject efObject) { if (_checkXObject && efObject.XObject == null) { // some EFAttributes are not tied to XAttributes var efAttribute = efObject as EFAttribute; var parentElement = efObject.Parent as EFElement; if (efAttribute != null && parentElement != null) { var xattr = efAttribute.Namespace != null ? parentElement.GetAttribute(efObject.EFTypeName, efAttribute.Namespace.NamespaceName) : parentElement.GetAttribute(efObject.EFTypeName); if (xattr == null) { return true; } } if (!_noXObjectList.Contains(efObject)) { _noXObjectList.Add(efObject); } return true; } return false; }
private bool CheckForUnresolved(EFObject efObject) { var efElement = efObject as EFElement; var itemBinding = efObject as ItemBinding; var parentElement = efObject.Parent as EFElement; if (_checkUnresolved) { if (efElement != null) { if (!(efElement.State == EFElementState.Resolved || efElement.State == EFElementState.ResolveAttempted)) { if (!_unresolvedList.Contains(efObject)) { _unresolvedList.Add(efObject); } return true; } } else if (itemBinding != null) { if (itemBinding.Parent.State == EFElementState.Resolved && (itemBinding.Resolved == false || itemBinding.IsStatusUnknown)) { var xattr = parentElement.GetAttribute(efObject.EFTypeName); if (xattr == null) { return true; } if (!_unresolvedList.Contains(efObject)) { _unresolvedList.Add(efObject); } return true; } } } return false; }
private bool CheckForDisposed(EFObject efObject) { if (_checkDisposed && efObject.IsDisposed) { if (!_disposedList.Contains(efObject)) { _disposedList.Add(efObject); } return true; } return false; }
// <summary> // Returns a wrapper for the specified EFObject. The wrapper is the type descriptor // that describes the properties that should be displayed for the EFObject. // The returned wrapper should be handed to a property window control // </summary> public static ObjectDescriptor GetObjectDescriptor(EFObject obj, EditingContext editingContext, bool runningInVS) { if (obj != null) { Type objectDescriptorType; if (ObjectDescriptorTypes.TryGetValue(obj.GetType(), out objectDescriptorType)) { // create the descriptor wrapper for the EFObject object var descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, objectDescriptorType, null, null); descriptor.Initialize(obj, editingContext, runningInVS); return descriptor; } else { // special case for Property var property = obj as Property; if (property != null) { ObjectDescriptor descriptor = null; if (property is ComplexConceptualProperty) { descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFComplexPropertyDescriptor), null, null); } else if (property.EntityModel.IsCSDL) { descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFPropertyDescriptor), null, null); } else { descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFSPropertyDescriptor), null, null); } descriptor.Initialize(obj, editingContext, runningInVS); return descriptor; } // special case for Parameter var parameter = obj as Parameter; if (parameter != null) { ObjectDescriptor descriptor = null; if (parameter.Parent is FunctionImport) { descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFParameterDescriptor), null, null); descriptor.Initialize(obj, editingContext, runningInVS); return descriptor; } else if (parameter.Parent is Function) { //Stored procedure parameter descriptor (EFSParameterDescriptor) descriptor = (ObjectDescriptor)TypeDescriptor.CreateInstance(null, typeof(EFSParameterDescriptor), null, null); descriptor.Initialize(obj, editingContext, runningInVS); return descriptor; } } } } return null; }
/// <summary> /// </summary> /// <param name="efObject"></param> /// <returns></returns> protected abstract EFElement GetNavigationTarget(EFObject efObject);
internal ExplorerEFElement GetExplorerEFElementForEFObject(EditingContext editingContext, EFObject targetEFObject) { if (targetEFObject == null) { return null; } // // Find the EFObject we want to navigate to for the given EFObject // var targetEFElement = GetNavigationTarget(targetEFObject); // // get all EFElement nodes on the path from our target node to the root. // var elementStack = new LinkedList<EFElement>(); var e = targetEFElement; while (e != null) { elementStack.AddLast(e); e = e.Parent as EFElement; } // // unwind the stack, making sure that each element's explorer model node exists. // var explorerElement = ViewModel.RootNode; while (elementStack.Count > 0) { var e2 = elementStack.Last.Value; elementStack.RemoveLast(); var viewModelType = ModelToExplorerModelXRef.GetViewModelTypeForEFlement(editingContext, e2); // if viewModelType is null then that kind of EFElement is not displayed // in the Explorer (e.g. S-side StorageEntityContainer and children) if (null != viewModelType) { var nextElement = ModelToExplorerModelXRef.GetNewOrExisting(editingContext, e2, explorerElement, viewModelType); // There are "dummy-nodes" in the view-model that don't correspond to a node in the model. // We need to skip over them here. if (nextElement != null && elementStack.Count > 0) { nextElement = nextElement.GetParentNodeForElement(elementStack.Last.Value); Debug.Assert(nextElement != null, "GetParentNodeForElement returned null"); } if (nextElement != null) { explorerElement = nextElement; } } } Debug.Assert(explorerElement != null, "no explorer element found for targetEFObject"); if (explorerElement != null) { // // now make sure that our target node in the explorer tree is visible. // explorerElement.ExpandTreeViewToMe(); } return explorerElement; }
internal ICollection<EFObject> GetAntiDependenciesClosure(EFObject item) { return _dependencyGraph.GetAntiDependenciesClosure(item); }
internal void RemoveErrorsForEFObject(EFObject efobject, ErrorClass errorClass, int errorCodeToRemove) { Dictionary<ErrorClass, ICollection<ErrorInfo>> errorClass2ErrorInfo = null; _artifacts2Errors.TryGetValue(efobject.Artifact, out errorClass2ErrorInfo); if (errorClass2ErrorInfo != null) { foreach (var errors in GetErrorInfosUsingMask(errorClass2ErrorInfo, errorClass)) { var errorsToRemove = new List<ErrorInfo>(); foreach (var errorInfo in errors) { if (errorInfo.ErrorCode == errorCodeToRemove) { errorsToRemove.Add(errorInfo); } } foreach (var errorInfo in errorsToRemove) { errors.Remove(errorInfo); } } } }
/// <summary> /// Gets a value indicating whether the EFObject should be visited. /// </summary> protected virtual bool ShouldVisit(EFObject efObject) { return true; }
/// <summary> /// Gets a value indicating whether the EFObject is a valid ghost node. /// </summary> /// <remarks> /// A valid ghost node will not cause an error if it has an incorrect or stale xlinq annotation. /// </remarks> protected virtual bool IsValidGhostNode(EFObject efObject) { return false; }
/// <summary> /// This method makes sure that: /// 1. Any given item is not duplicated in the list /// 2. If the newDeleted item's parent is already in the list, don't add it /// 3. If any children of newDeleted are already in the list, remove the child item /// This greatly optimizes the actually CleanUp() process. /// </summary> /// <param name="newDeleted"></param> private void AddToDeleteList(EFObject newDeleted) { // if newDeleted is already there, just return if (_itemsToDelete.Contains(newDeleted)) { return; } // don't add newDeleted if any of its parents are already being deleted var container = newDeleted.Parent; while (container != null) { if (_itemsToDelete.Contains(container)) { return; } container = container.Parent; } // if the newDeleted item is the parent of an existing item // remove the child item and just add the parent below RemoveChildrenOfNewDeleted(newDeleted as EFContainer); // add the item _itemsToDelete.Add(newDeleted); }
internal abstract XNamespace GetRootNamespace(EFObject node);