private static IEnumerable <ExplorerEFElement> AncestorsFromNode(ExplorerEFElement startNode) { var e = startNode; while (e != null) { yield return(e); e = e.Parent; } }
internal ExplorerEFElement GetExistingOrParent(EFElement efElement) { ExplorerEFElement result = null; while (result == null && efElement != null) { if (!_dict.TryGetValue(efElement, out result)) { efElement = efElement.Parent as EFElement; } } return(result); }
protected override bool RemoveChild(ExplorerEFElement efElementToRemove) { var explorerProperty = efElementToRemove as ExplorerProperty; if (explorerProperty != null) { var indexOfRemovedChild = _properties.Remove(explorerProperty); return((indexOfRemovedChild < 0) ? false : true); } Debug.Fail( string.Format( CultureInfo.CurrentCulture, Resources.BadRemoveBadChildType, efElementToRemove.GetType().FullName, Name, GetType().FullName)); return(false); }
protected override bool RemoveChild(ExplorerEFElement efElementToRemove) { var explorerEntityContainer = efElementToRemove as ExplorerConceptualEntityContainer; if (explorerEntityContainer == null) { Debug.Fail( string.Format( CultureInfo.CurrentCulture, Resources.BadRemoveBadChildType, efElementToRemove.GetType().FullName, Name, GetType().FullName)); return(false); } var indexOfRemovedChild = _entityContainers.Remove(explorerEntityContainer); return((indexOfRemovedChild < 0) ? false : true); }
/// <summary> /// If the element being removed is part of the Search Results then /// removes it from the Search Results list /// </summary> /// <param name="elementToBeRemoved">element to be removed</param> /// <returns>whether removal was successful</returns> internal bool RemoveElementFromSearchResults(ExplorerEFElement elementToBeRemoved) { if (null == elementToBeRemoved) { Debug.Fail( typeof(ExplorerSearchResults).Name + ".RemoveElementFromSearchResults() received null elementToBeRemoved"); return(false); } if (elementToBeRemoved.IsInSearchResults) { elementToBeRemoved.IsInSearchResults = false; return(_results.Remove(elementToBeRemoved)); } return(false); }
protected override bool RemoveChild(ExplorerEFElement efElementToRemove) { var explorerAssocSet = efElementToRemove as ExplorerAssociationSet; if (explorerAssocSet == null) { Debug.Fail( string.Format( CultureInfo.CurrentCulture, Resources.BadRemoveBadChildType, efElementToRemove.GetType().FullName, Name, GetType().FullName)); return(false); } var indexOfRemovedChild = _associationSets.Remove(explorerAssocSet); return((indexOfRemovedChild < 0) ? false : true); }
protected override bool RemoveChild(ExplorerEFElement efElementToRemove) { var explorerEntityTypeShape = efElementToRemove as ExplorerEntityTypeShape; if (explorerEntityTypeShape == null) { Debug.Fail( string.Format( CultureInfo.CurrentCulture, Resources.BadRemoveBadChildType, efElementToRemove.GetType().FullName, Name, GetType().FullName)); return(false); } // We can't use TypedChildList's Remove to delete the entity-type-shape because the it will fail if the underlying entity-type has been deleted. // When the entity-type is deleted, the name of the entity-type-shape will change to an empty string and deletion will fail // until the list is re-sorted (see implementation of ExplorerEFElement's Remove). return(_explorerEntityTypeShapes.ChildList.Remove(explorerEntityTypeShape)); }
// Must have public constructor to allow creation by reflection // in EditingContext.GetValue() internal void Reset() { if (null != _results) { foreach (var explorerElement in _results) { explorerElement.IsInSearchResults = false; } _results.Clear(); } _previousSearchResultItem = null; _previousSearchResultItemIndex = -1; _nextSearchResultItem = null; _nextSearchResultItemIndex = -1; _currentSelectionIsInResults = false; _targetString = null; _elementTextToSearch = null; }
private static ExplorerEFElement GetNewOrExisting( EditingContext context, EFElement efElement, ExplorerEFElement parent, Type viewModelType, bool mustNotExist) { var xref = GetModelToBrowserModelXRef(context); var result = xref.GetExisting(efElement); if (result != null) { if (mustNotExist) { Debug.Fail( string.Format( CultureInfo.CurrentCulture, Resources.BadInsertChildAlreadyExists, efElement.GetType().FullName, parent.GetType().FullName)); return(null); // TODO: we need to provide a general exception-handling mechanism and replace the above Assert() // by e.g. the excepiton below // throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, Resources.BadInsertChildAlreadyExists, efElement.GetType().FullName, parent.GetType().FullName)); } else { result.Parent = parent; } } else { if (viewModelType != null) { if (!xref.IsDisplayedInExplorerProtected(efElement)) { Debug.Fail( "Attempting to create an ExplorerEFElement of type " + viewModelType.FullName + " based on an EFElement which is not displayed in the Explorer " + efElement.ToPrettyString()); return(null); } result = Activator.CreateInstance(viewModelType, context, efElement, parent) as ExplorerEFElement; xref.Add(efElement, result); } } return(result); }
/// <summary> /// Get previous Search Result and update Next and Previous pointers /// </summary> internal ExplorerEFElement SelectPreviousSearchResult() { var itemToBeReturned = _previousSearchResultItem; if (null != _previousSearchResultItem) { if (_currentSelectionIsInResults) { if (null == _nextSearchResultItem) { // there was no next search item - make the next item the end of the list _nextSearchResultItemIndex = _results.Count - 1; } else { _nextSearchResultItemIndex--; } _nextSearchResultItem = _results[_nextSearchResultItemIndex]; } else { // the currently selected item is now in the results // but Next does not need to be updated _currentSelectionIsInResults = true; } _previousSearchResultItemIndex--; if (_previousSearchResultItemIndex < 0) { _previousSearchResultItem = null; _previousSearchResultItemIndex = -1; } else { _previousSearchResultItem = _results[_previousSearchResultItemIndex]; } } return(itemToBeReturned); }
/// <summary> /// Get next Search Result and update Next and Previous items /// </summary> internal ExplorerEFElement SelectNextSearchResult() { var itemToBeReturned = _nextSearchResultItem; if (null != _nextSearchResultItem) { if (_currentSelectionIsInResults) { if (null == _previousSearchResultItem) { // there was no previous search item - make the previous item the start of the list _previousSearchResultItemIndex = 0; } else { _previousSearchResultItemIndex++; } _previousSearchResultItem = _results[_previousSearchResultItemIndex]; } else { // the currently selected item is now in the results // but Previous does not need to be updated _currentSelectionIsInResults = true; } _nextSearchResultItemIndex++; if (_nextSearchResultItemIndex >= _results.Count) { _nextSearchResultItem = null; _nextSearchResultItemIndex = -1; } else { _nextSearchResultItem = _results[_nextSearchResultItemIndex]; } } return(itemToBeReturned); }
internal static ExplorerEFElement GetParentExplorerElement(EditingContext context, EFElement efElement) { // Finds the Explorer parent of the efElement // The explorer parent may not be the same as model parent ExplorerEFElement explorerParentItem = null; var parent = efElement.Parent as EFElement; if (parent != null) { var xref = GetModelToBrowserModelXRef(context); var currentItem = efElement; while (explorerParentItem == null && currentItem != null) { currentItem = currentItem.Parent as EFElement; explorerParentItem = xref.GetExisting(currentItem); } } return(explorerParentItem); }
public ExplorerConceptualEntityContainer( EditingContext context, ConceptualEntityContainer entityContainer, ExplorerEFElement parent) : base(context, entityContainer, parent) { }
public ExplorerAssociationSet(EditingContext context, AssociationSet assocSet, ExplorerEFElement parent) : base(context, assocSet, parent) { // do nothing }
public ExplorerParameter(EditingContext context, Parameter parameter, ExplorerEFElement parent) : base(context, parameter, parent) { // do nothing }
public ExplorerEntitySet(EditingContext context, EntitySet entitySet, ExplorerEFElement parent) : base(context, entitySet, parent) { // do nothing }
internal static ExplorerEFElement GetNewOrExisting( EditingContext context, EFElement efElement, ExplorerEFElement parent, Type viewModelType) { return(GetNewOrExisting(context, efElement, parent, viewModelType, false)); }
private void Add(EFElement efElement, ExplorerEFElement explorerEFElement) { _dict.Add(efElement, explorerEFElement); }
public ExplorerEnumType(EditingContext context, EnumType enumType, ExplorerEFElement parent) : base(context, enumType, parent) { // do nothing }
public ExplorerNavigationProperty(EditingContext context, NavigationProperty navigationProperty, ExplorerEFElement parent) : base(context, navigationProperty, parent) { // do nothing }
/// <summary> /// Removes a child element from this object /// </summary> /// <param name="explorerElement">the element to remove</param> /// <returns>true if element was successfully removed, false otherwise</returns> protected virtual bool RemoveChild(ExplorerEFElement explorerElement) { return(false); }
public ExplorerConceptualProperty(EditingContext context, Property property, ExplorerEFElement parent) : base(context, property, parent) { // do nothing }
public ExplorerConceptualEntityModel(EditingContext context, ConceptualEntityModel entityModel, ExplorerEFElement parent) : base(context, entityModel, parent) { _typesGhostNode = new ExplorerTypes( Resources.ConceptualTypesGhostNodeName, context, this); _complexTypesGhostNode = new ExplorerComplexTypes(Resources.ComplexTypesGhostNodeName, context, this); _assocsGhostNode = new ExplorerAssociations( Resources.ConceptualAssociationsGhostNodeName, context, this); _funcImportsGhostNode = new ExplorerFunctionImports( Resources.FunctionImportsGhostNodeName, context, this); _enumTypesGhostNode = null; if (EdmFeatureManager.GetEnumTypeFeatureState(entityModel.Artifact).IsEnabled()) { _enumTypesGhostNode = new ExplorerEnumTypes( Resources.EnumTypesGhostNodeName, context, this); } }
public ExplorerStorageEntityModel(EditingContext context, StorageEntityModel entityModel, ExplorerEFElement parent) : base(context, entityModel, parent) { _typesGhostNode = new ExplorerTypes( Resources.StorageTypesGhostNodeName, context, this); _funcsGhostNode = new ExplorerFunctions( Resources.StorageFunctionsGhostNodeName, context, this); _assocsGhostNode = new ExplorerAssociations( Resources.StorageAssociationsGhostNodeName, context, this); }
protected EntityDesignExplorerEFElement(EditingContext context, EFElement modelItem, ExplorerEFElement parent) : base(context, modelItem, parent) { }
public ExplorerConceptualEntityType(EditingContext context, EntityType entityType, ExplorerEFElement parent) : base(context, entityType, parent) { // do nothing }
public ExplorerEntityContainerAssociationSets(string name, EditingContext context, ExplorerEFElement parent) : base(context, null, parent) { if (name != null) { base.Name = name; } }
protected override bool ProcessCreateOrDeleteChange(EditingContext ctx, ModelToExplorerModelXRef xref, EfiChange change) { var artifact = change.Changed as EFArtifact; var conceptualModel = change.Changed as ConceptualEntityModel; var storageModel = change.Changed as StorageEntityModel; var mappingModel = change.Changed as MappingModel; if (null != artifact || null != conceptualModel || null != storageModel || null != mappingModel) { // reset the search results - they will no longer be valid // once the view model is recalculated below var explorerSearchResults = ExplorerSearchResults.GetExplorerSearchResults(ctx); explorerSearchResults.Reset(); // reload the UI - the ExplorerViewModelChanged will be fired // allowing the frame to rebind CreateViewModel(ctx); // don't process any more return(false); } var efElement = change.Changed as EFElement; // ExplorerViewModelHelper only needs to process EFElement changes // (others are DefaultableValue and SingleItemBinding - but // ExplorerViewModel does not currently need to map these latter) if (null != efElement) { var parent = efElement.Parent as EFElement; Debug.Assert( null != parent, "received changed element of type " + change.Changed.GetType().FullName + " with non-EFElement parent of type " + (efElement.Parent == null ? "NULL" : efElement.Parent.GetType().FullName)); if (null != parent) { // special case changing of an entity's key // If we are creating/deleting a Key PropertyRef then we need // to update the underlying ExplorerProperty var propRef = efElement as PropertyRef; var keyElement = efElement as Key; if (propRef != null) { keyElement = propRef.GetParentOfType(typeof(Key)) as Key; if (keyElement != null && null != propRef.Name && null != propRef.Name.Target) { ExplorerEFElement explorerProp = xref.GetExisting(propRef.Name.Target) as ExplorerProperty; if (null != explorerProp) { explorerProp.OnModelPropertyChanged(ExplorerEFElement.IsKeyPropertyID); } } } else if (keyElement != null) { // key must be a child of an entity var et = parent as EntityType; if (et != null) { // the key is being created or completely removed, so sync up every property foreach (var prop in et.Properties()) { ExplorerEFElement explorerProp = xref.GetExisting(prop) as ExplorerProperty; if (null != explorerProp) { explorerProp.OnModelPropertyChanged(ExplorerEFElement.IsKeyPropertyID); } } } } else { // find Explorer node which maps to the model's parent // this can be null is the ViewModel does not map the // parent object if (typeof(FunctionImport) == efElement.GetType()) { // the FunctionImport Explorer Parent node has been decided to be the ConceptualEntityModel ExplorerEFElement // rather than the ConceptualEntityContainer one which we would more naturally use to match the model setup parent = parent.Parent as EFElement; } var explorerParentItem = xref.GetExisting(parent); if (null != explorerParentItem) { // now find the Explorer node which should be the new/deleted ViewModel element's parent // (may not be the same as above due to Explorer ghost nodes) explorerParentItem = explorerParentItem.GetParentNodeForElement(efElement); if (EfiChange.EfiChangeType.Create == change.Type) { // It's possible that between the Create of a parent and its child // the Children property is called on the parent which loads the // child into the parent, even though the child is being added with // change.Type = Create. For safety, we should remove the existing // child (if it exists) so as to ensure any changes in the child change // are reflected. var explorerEFElement = xref.GetExisting(efElement); if (explorerEFElement != null) { explorerParentItem.RemoveChildIfLoaded(efElement); } explorerParentItem.InsertChildIfLoaded(efElement); } else { explorerParentItem.RemoveChildIfLoaded(efElement); } } } } } return(true); }
public ExplorerConceptualAssociation(EditingContext context, Association assoc, ExplorerEFElement parent) : base(context, assoc, parent) { // do nothing }
internal static int HierarchyCompare(ExplorerEFElement element1, ExplorerEFElement element2) { var element1PathFromRoot = element1.SelfAndAncestors().Reverse(); var element2PathFromRoot = element2.SelfAndAncestors().Reverse(); var element1PathFromRootEnumerator = element1PathFromRoot.GetEnumerator(); var element2PathFromRootEnumerator = element2PathFromRoot.GetEnumerator(); ExplorerEFElement jointParent = null; ExplorerEFElement path1Child = null; ExplorerEFElement path2Child = null; while (true) { // Note: must update _both_ child elements so cannot use && operator in while loop if (element1PathFromRootEnumerator.MoveNext()) { path1Child = element1PathFromRootEnumerator.Current; } else { path1Child = null; } if (element2PathFromRootEnumerator.MoveNext()) { path2Child = element2PathFromRootEnumerator.Current; } else { path2Child = null; } if (null == path1Child || null == path2Child) { // have reached end of at least one path break; } if (path1Child == path2Child) { // update joint parent jointParent = path1Child; } else { // have found point where trees differ break; } } if (null == jointParent) { Debug.Assert( false, "efElement1PathFromRoot and efElement2PathFromRoot have no common ancestor - they should at least have the same root node"); return(0); } // now compare if (null == path1Child && null == path2Child) { // paths were the same - so ends were the same return(0); } else if (null == path1Child) { // element1 = jointParent, element2 = child of jointParent return(-1); } else if (null == path2Child) { // element1 = child of jointParent, element2 = jointParent return(1); } else { // comparing 2 children of jointParent return(jointParent.CompareChildren(path1Child, path2Child)); } }