/// <summary> /// Add a group of interdependent properties (i.e. if one of them changes, all of them change) /// </summary> /// <typeparam name="Type">The type</typeparam> /// <param name="propertyNamesDest">The list of property names</param> protected static void AddDependencyGroup <Type>(params string[] propertyNamesDest) { var type = typeof(Type); if (!ValidatePublicPropertyNames(type, propertyNamesDest)) { throw new ArgumentException("A destination property is not a property of the given type", "propertyNamesDest"); } if (!DependentProperties.ContainsKey(type)) { DependentProperties[type] = new Dictionary <string, List <string> >(); } foreach (var propertyNameSource in propertyNamesDest) { if (!DependentProperties[type].ContainsKey(propertyNameSource)) { DependentProperties[type][propertyNameSource] = new List <string>(); } foreach (var name in propertyNamesDest) { if (name == propertyNameSource) { continue; } if (DependentProperties[type][propertyNameSource].Any(item => item == name)) { continue; } DependentProperties[type][propertyNameSource].Add(name); } } }
/// <summary> /// Constructs the object; remembers the callers' type for looking up dependent properties /// efficiently /// </summary> /// <param name="callerType">The callers (i.e. derived class) type</param> protected NotifyPropertyChangedImpl(Type callerType) { if (DependentProperties.ContainsKey(callerType)) { CallerType = callerType; } }
public IEnumerable <ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context) { var rule = new ModelClientValidationRule() { ErrorMessage = FormatErrorMessage(metadata.GetDisplayName()), ValidationType = "requiredifany", }; var properties = new List <string>(); var values = new List <object>(); for (int i = 0; i < DependentProperties.Count(); i++) { string depProp = BuildDependentPropertyId(metadata, context as ViewContext, DependentProperties[i]); // find the value on the control we depend on; // if it's a bool, format it javascript style // (the default is True or False!) string targetValue = (TargetValues[i] ?? "").ToString(); if (TargetValues[i].GetType() == typeof(bool)) { targetValue = targetValue.ToLower(); } properties.Add(depProp); values.Add(targetValue); } rule.ValidationParameters.Add("dependentproperties", String.Join("|", properties)); rule.ValidationParameters.Add("targetvalues", String.Join("|", values)); yield return(rule); }
/// <summary> /// Manages a property modification and its notifications. A function is provided to check whether the new value is different from the current one. /// This function will be invoked by this method, and if it returns <c>True</c>, it will invoke the provided update action. The <see cref="ViewModelBase.PropertyChanging"/> /// event will be raised prior to the update action, and the <see cref="ViewModelBase.PropertyChanged"/> event will be raised after. /// </summary> /// <remarks>This method does not register <see cref="IActionItem"/> into the associated <see cref="ITransactionalActionStack"/>.</remarks> /// <param name="hasChangedFunction">A function that check if the new value is different and therefore if the update must be actually done.</param> /// <param name="updateAction">The update action that will actually manage the update of the property.</param> /// <param name="propertyNames">The names of the properties that must be notified as changing/changed. At least one property name must be provided.</param> /// <returns><c>True</c> if the update was done and events were raised, <c>False</c> if <see cref="hasChangedFunction"/> is not <c>null</c> and returned false.</returns> protected virtual bool SetValueUncancellable(Func <bool> hasChangedFunction, Action updateAction, params string[] propertyNames) { foreach (var propertyName in propertyNames) { uncancellableChanges.Add(propertyName); string[] dependentProperties; if (DependentProperties.TryGetValue(propertyName, out dependentProperties)) { dependentProperties.ForEach(x => uncancellableChanges.Add(x)); } } try { var result = SetValue(hasChangedFunction, updateAction, propertyNames); return(result); } finally { foreach (var propertyName in propertyNames) { uncancellableChanges.Remove(propertyName); string[] dependentProperties; if (DependentProperties.TryGetValue(propertyName, out dependentProperties)) { dependentProperties.ForEach(x => uncancellableChanges.Remove(x)); } } } }
protected override ValidationResult IsValid(object value, ValidationContext validationContext) { for (int i = 0; i < DependentProperties.Count(); i++) { // get a reference to the property this validation depends upon var containerType = validationContext.ObjectInstance.GetType(); var field = containerType.GetProperty(this.DependentProperties[i]); if (field != null) { // get the value of the dependent property var dependentvalue = field.GetValue(validationContext.ObjectInstance, null); // compare the value against the target value if ((dependentvalue == null && this.TargetValues[i] == null) || (dependentvalue != null && dependentvalue.Equals(this.TargetValues[i]))) { // match => means we should try validating this field if (!_innerAttribute.IsValid(value)) { // validation failed - return an error return(new ValidationResult(this.ErrorMessage, new[] { validationContext.MemberName })); } } } } return(ValidationResult.Success); }
protected bool SetValueUncancellable <T>(ref T field, T value, Action updateAction, [ItemNotNull, NotNull] params string[] propertyNames) { foreach (var propertyName in propertyNames) { uncancellableChanges.Add(propertyName); string[] dependentProperties; if (DependentProperties.TryGetValue(propertyName, out dependentProperties)) { dependentProperties.ForEach(x => uncancellableChanges.Add(x)); } } try { var result = SetValue(ref field, value, updateAction, false, propertyNames); return(result); } finally { foreach (var propertyName in propertyNames) { uncancellableChanges.Remove(propertyName); string[] dependentProperties; if (DependentProperties.TryGetValue(propertyName, out dependentProperties)) { dependentProperties.ForEach(x => uncancellableChanges.Remove(x)); } } } }
protected ControlPointViewModelBase([NotNull] CurveViewModelBase curve) : base(curve.SafeArgument(nameof(curve)).ServiceProvider) { Curve = curve; DependentProperties.Add(nameof(Point), new[] { nameof(ActualKey), nameof(ActualPoint), nameof(ActualValue) }); }
protected CombinedObservableNode(ObservableViewModel ownerViewModel, string name, IEnumerable <SingleObservableNode> combinedNodes, Index index) : base(ownerViewModel, index) { // ReSharper disable once DoNotCallOverridableMethodsInConstructor DependentProperties.Add(nameof(Value), new[] { nameof(HasMultipleValues), nameof(IsPrimitive), nameof(HasList), nameof(HasDictionary) }); this.combinedNodes = new List <SingleObservableNode>(combinedNodes); Name = name; DisplayName = this.combinedNodes.First().DisplayName; combinedNodeInitialValues = new List <object>(); distinctCombinedNodeInitialValues = new HashSet <object>(); bool isReadOnly = false; bool isVisible = false; bool nullOrder = false; foreach (var node in this.combinedNodes) { if (node.IsDisposed) { throw new InvalidOperationException("One of the combined node is already disposed."); } if (node.IsReadOnly) { isReadOnly = true; } if (node.IsVisible) { isVisible = true; } if (node.Order == null) { nullOrder = true; } if (order == node.Order || (!nullOrder && order == null)) { order = node.Order; } combinedNodeInitialValues.Add(node.Value); distinctCombinedNodeInitialValues.Add(node.Value); } IsReadOnly = isReadOnly; IsVisible = isVisible; ResetInitialValues = new AnonymousCommand(ServiceProvider, () => { using (Owner.BeginCombinedAction(Owner.FormatCombinedUpdateMessage(this, null), Path)) { CombinedNodes.Zip(combinedNodeInitialValues).ForEach(x => x.Item1.Value = x.Item2); Refresh(); } }); }
protected DirectoryBaseViewModel(SessionViewModel session) : base(session) { SubDirectories = new ReadOnlyObservableCollection <DirectoryViewModel>(subDirectories); // ReSharper disable DoNotCallOverridableMethodsInConstructor - looks like an issue in resharper DependentProperties.Add(nameof(Parent), new[] { nameof(Path), nameof(Package), nameof(Root) }); // ReSharper restore DoNotCallOverridableMethodsInConstructor RegisterMemberCollectionForActionStack(nameof(Assets), Assets); }
/// <summary> /// Initializes a new instance of the <see cref="SolutionPlatformViewModel"/> class. /// </summary> /// <param name="serviceProvider">The service provider for this view model.</param> /// <param name="solutionPlatform">The solution platform represented by the view model.</param> /// <param name="isAlreadyInstalled">Indicates whether this plaform is already installed in the related package.</param> /// <param name="initiallySelected">Indicates whether this plaform should be initially selected.</param> public SolutionPlatformViewModel(IViewModelServiceProvider serviceProvider, SolutionPlatform solutionPlatform, bool isAlreadyInstalled, bool initiallySelected) : base(serviceProvider) { SolutionPlatform = solutionPlatform; IsAvailableOnMachine = solutionPlatform.IsAvailable; IsSelected = initiallySelected; IsAlreadyInstalled = isAlreadyInstalled; DependentProperties.Add(nameof(IsSelected), new[] { nameof(MarkedToRemove) }); SelectedTemplate = AvailableTemplates.FirstOrDefault(); }
protected NodeViewModel(GraphViewModel ownerViewModel, Index index) : base(ownerViewModel.ServiceProvider) { DependentProperties.Add(nameof(Path), new[] { nameof(DisplayPath) }); Owner = ownerViewModel; Index = index; Guid = Guid.NewGuid(); IsVisible = true; IsReadOnly = false; }
protected EntityHierarchyElementViewModel([NotNull] EntityHierarchyEditorViewModel editor, [NotNull] EntityHierarchyViewModel asset, [NotNull] IEnumerable <EntityDesign> childEntities, object assetSideInstance) : base(editor, asset, childEntities) { this.assetSideInstance = assetSideInstance; LoadCommand = new AnonymousTaskCommand <bool>(ServiceProvider, recursive => RequestLoading(!IsLoaded, recursive)); LockCommand = new AnonymousTaskCommand <bool>(ServiceProvider, recursive => RequestLocking(!IsLocked, recursive)); DependentProperties.Add(nameof(IsLoaded), new[] { nameof(IsSelectable) }); DependentProperties.Add(nameof(IsLocked), new[] { nameof(IsSelectable) }); }
public TemplateDescriptionGroupViewModel(IViewModelServiceProvider serviceProvider, string name) : base(serviceProvider) { if (name == null) { throw new ArgumentNullException(nameof(name)); } Name = name; Templates = new ObservableList <ITemplateDescriptionViewModel>(); DependentProperties.Add(nameof(Parent), new[] { nameof(Path) }); }
/// <summary> /// Initializes a new instance of the <see cref="ViewportViewModel"/> class. /// </summary> /// <param name="serviceProvider">The service provider to use with this view model.</param> public ViewportViewModel(IViewModelServiceProvider serviceProvider) : base(serviceProvider) { DependentProperties.Add(nameof(ContentWidth), new[] { nameof(ActualContentWidth) }); DependentProperties.Add(nameof(ContentHeight), new[] { nameof(ActualContentHeight) }); DependentProperties.Add(nameof(ScaleFactor), new[] { nameof(ActualContentWidth), nameof(ActualContentHeight) }); FitOnScreenCommand = new AnonymousCommand(ServiceProvider, FitOnScreen); ScaleToRealSizeCommand = new AnonymousCommand(ServiceProvider, ScaleToRealSize); ZoomInCommand = new AnonymousCommand(ServiceProvider, () => ZoomIn(ViewportWidth * 0.5, ViewportHeight * 0.5)); ZoomOutCommand = new AnonymousCommand(ServiceProvider, () => ZoomOut(ViewportWidth * 0.5, ViewportHeight * 0.5)); }
public SpriteBordersViewModel(SpriteInfoViewModel sprite, IObjectNode spriteNode) : base(sprite) { textureRegionNode = spriteNode[nameof(SpriteInfo.TextureRegion)]; textureRegionNode.ValueChanged += OnTextureRegionValueChanged; var spriteBordersNode = spriteNode[nameof(SpriteInfo.Borders)]; borderBinding = new MemberGraphNodeBinding <Vector4>(spriteBordersNode, nameof(Borders), OnPropertyChanging, OnPropertyChanged, UndoRedoService); DependentProperties.Add(nameof(Borders), new[] { nameof(ActualBorders) }); DependentProperties.Add(nameof(ScaleFactor), new[] { nameof(ActualBorders) }); }
public SpriteSheetPreviewViewModel(SessionViewModel session) : base(session) { PreviewPreviousFrameCommand = new AnonymousCommand(ServiceProvider, () => { if (PreviewFrameCount > 0) { PreviewCurrentFrame = 1 + (PreviewCurrentFrame + PreviewFrameCount - 2) % PreviewFrameCount; } }); PreviewNextFrameCommand = new AnonymousCommand(ServiceProvider, () => { if (PreviewFrameCount > 0) { PreviewCurrentFrame = 1 + (PreviewCurrentFrame + PreviewFrameCount) % PreviewFrameCount; } }); DependentProperties.Add(nameof(DisplayMode), new[] { nameof(PreviewCurrentFrame), nameof(PreviewFrameCount) }); }
public TextureRegionViewModel(SpriteInfoViewModel sprite, IMemberNode textureRegionNode) : base(sprite) { if (sprite.Editor.Cache != null) { RefreshImageSize(); } else { sprite.Editor.Initialized += EditorInitialized; } textureRegionBinding = new MemberGraphNodeBinding <RectangleF, Rectangle>(textureRegionNode, nameof(Region), OnPropertyChanging, OnPropertyChanged, x => (Rectangle)x, UndoRedoService); DependentProperties.Add(nameof(Region), new[] { nameof(ActualLeft), nameof(ActualTop), nameof(ActualWidth), nameof(ActualHeight), nameof(ActualRightOffset), nameof(ActualBottomOffset) }); DependentProperties.Add(nameof(ScaleFactor), new[] { nameof(ActualLeft), nameof(ActualTop), nameof(ActualWidth), nameof(ActualHeight), nameof(ActualRightOffset), nameof(ActualBottomOffset) }); DependentProperties.Add(nameof(ImageWidth), new[] { nameof(ActualRightOffset), nameof(ActualBottomOffset) }); DependentProperties.Add(nameof(ImageHeight), new[] { nameof(ActualRightOffset), nameof(ActualBottomOffset) }); }
public SpriteCenterViewModel(SpriteInfoViewModel sprite, IObjectNode spriteNode) : base(sprite) { var spriteCenterNode = spriteNode[nameof(SpriteInfo.Center)]; spriteCenterNodeBinding = new MemberGraphNodeBinding <Vector2>(spriteCenterNode, nameof(Center), OnPropertyChanging, OnPropertyChanged, UndoRedoService); var centerFromMiddleNode = spriteNode[nameof(SpriteInfo.CenterFromMiddle)]; centerFromMiddleBinding = new MemberGraphNodeBinding <bool>(centerFromMiddleNode, nameof(CenterFromMiddle), OnPropertyChanging, OnPropertyChanged, UndoRedoService); var textureRegionNode = spriteNode[nameof(SpriteInfo.TextureRegion)]; textureRegionBinding = new MemberGraphNodeBinding <Rectangle>(textureRegionNode, nameof(ActualCenter), OnPropertyChanging, OnPropertyChanged, UndoRedoService); DependentProperties.Add(nameof(Center), new[] { nameof(ActualCenter) }); DependentProperties.Add(nameof(CenterFromMiddle), new[] { nameof(ActualCenter) }); DependentProperties.Add(nameof(ScaleFactor), new[] { nameof(ActualCenter) }); }
public PackageViewModel(SessionViewModel session, PackageContainer packageContainer, bool packageAlreadyInSession) : base(session) { PackageContainer = packageContainer; Package = PackageContainer.Package; HasBeenUpgraded = Package.IsDirty; DependentProperties.Add(nameof(PackagePath), new[] { nameof(Name), nameof(RootDirectory) }); Dependencies = new DependencyCategoryViewModel(nameof(Dependencies), this, session, Package.RootAssets); AssetMountPoint = new AssetMountPointViewModel(this); content.Add(AssetMountPoint); content.Add(Dependencies); RenameCommand = new AnonymousCommand(ServiceProvider, () => IsEditing = true); IsLoaded = Package.State >= PackageState.AssetsReady; // IsDeleted will make the package added to Session.LocalPackages, so let's do it last InitialUndelete(!packageAlreadyInSession); DeletedAssets.CollectionChanged += DeletedAssetsChanged; }
public SpriteSheetEditorViewModel([NotNull] SpriteSheetViewModel spriteSheet) : base(spriteSheet) { Viewport = new ViewportViewModel(ServiceProvider); // Commands DisplaySpriteSheetPropertiesCommand = new AnonymousCommand(ServiceProvider, DisplaySpriteSheetProperties); RemoveImageCommand = new AnonymousCommand(ServiceProvider, RemoveSelectedImages); SelectNextSpriteCommand = new AnonymousCommand <int>(ServiceProvider, SelectNextSprite); MoveImageCommand = new AnonymousCommand <int>(ServiceProvider, MoveImage); AddNewImageCommand = new AnonymousCommand(ServiceProvider, AddNewImage); UseWholeImageCommand = new AnonymousCommand(ServiceProvider, UseWholeImage); FocusOnRegionCommand = new AnonymousCommand(ServiceProvider, FocusOnRegion); DuplicateSelectedImagesCommand = new AnonymousCommand(ServiceProvider, DuplicateSelectedImages); CopyImageCommand = new AnonymousCommand(ServiceProvider, CopyImages, CanCopyImages); PasteImageCommand = new AnonymousCommand(ServiceProvider, PasteImages, () => pasteMonitor.Get(CanPasteImages)); FindSpriteRegionCommand = new AnonymousCommand <WindowsPoint>(ServiceProvider, FindSpriteRegion); ToggleSelectionHighlightCommand = new AnonymousCommand(ServiceProvider, () => SelectionHighlightEnabled = !SelectionHighlightEnabled); ToggleToolModeCommand = new AnonymousCommand <SpriteSheetEditorToolMode>(ServiceProvider, ToggleToolMode); ToggleUseMagicWandCommand = new AnonymousCommand(ServiceProvider, () => ToggleToolMode(SpriteSheetEditorToolMode.MagicWand)); SelectedSprites = new ObservableList <object>(); SelectedSprites.CollectionChanged += SelectedImagesCollectionChanged; ServiceProvider.Get <SelectionService>().RegisterSelectionScope(id => Sprites.FirstOrDefault(x => x.Id == id), obj => (obj as SpriteInfoViewModel)?.Id, SelectedSprites); sprites = new ObservableList <SpriteInfoViewModel>(Asset.Asset.Sprites.Select((x, i) => new SpriteInfoViewModel(this, x) { Index = i })); Sprites.CollectionChanged += ImageCollectionChanged; DependentProperties.Add(nameof(ToolMode), new[] { nameof(UsingPixelTool) }); magicWandUseTransparency = !Asset.Asset.ColorKeyEnabled; var rootNode = Session.AssetNodeContainer.GetNode(spriteSheet.Asset); spritesNode = rootNode[nameof(SpriteSheetAsset.Sprites)].Target; colorKeyNodeBinding = new MemberGraphNodeBinding <Color>(rootNode[nameof(SpriteSheetAsset.ColorKeyColor)], nameof(ColorKey), OnPropertyChanging, OnPropertyChanged, UndoRedoService); colorKeyEnabledNodeBinding = new MemberGraphNodeBinding <bool>(rootNode[nameof(SpriteSheetAsset.ColorKeyEnabled)], nameof(ColorKeyEnabled), OnPropertyChanging, OnPropertyChanged, UndoRedoService); typeNodeBinding = new MemberGraphNodeBinding <SpriteSheetType>(rootNode[nameof(SpriteSheetAsset.Type)], nameof(Type), OnPropertyChanging, OnPropertyChanged, UndoRedoService); // TODO: dispose this spritesNode.ItemChanged += SpritesContentChanged; }
internal LauncherViewModel(IViewModelServiceProvider serviceProvider, NugetStore store) : base(serviceProvider) { if (store == null) { throw new ArgumentNullException(nameof(store)); } DependentProperties.Add("ActiveVersion", new[] { "ActiveDocumentationPages" }); this.store = store; store.Logger = this; DisplayReleaseAnnouncement(); VsixPackage = new VsixVersionViewModel(this, store); // Commands InstallLatestVersionCommand = new AnonymousTaskCommand(ServiceProvider, InstallLatestVersion) { IsEnabled = false }; OpenUrlCommand = new AnonymousTaskCommand <string>(ServiceProvider, OpenUrl); ReconnectCommand = new AnonymousTaskCommand(ServiceProvider, async() => { // We are back online (or so we think) IsOffline = false; await FetchOnlineData(); }); StartStudioCommand = new AnonymousTaskCommand(ServiceProvider, StartStudio) { IsEnabled = false }; foreach (var devVersion in LauncherSettings.DeveloperVersions) { var version = new XenkoDevVersionViewModel(this, store, null, devVersion, false); xenkoVersions.Add(version); } FetchOnlineData().Forget(); LoadRecentProjects(); uninstallHelper = new UninstallHelper(serviceProvider, store); GameStudioSettings.RecentProjectsUpdated += (sender, e) => Dispatcher.InvokeAsync(LoadRecentProjects).Forget(); }
protected override void InvokeInternal(CommandProcessorContext cpc) { DesignerInfo designerInfo; Debug.Assert(cpc.Artifact != null, "Artifact was null"); if (Association != null && cpc.Artifact != null && cpc.Artifact.DesignerInfo() != null && cpc.Artifact.DesignerInfo().TryGetDesignerInfo(OptionsDesignerInfo.ElementName, out designerInfo)) { // APPDB_SCENARIO: We cannot use referential constraints for 0..1:0..1 or 1:1 associations, since these exist as configured // 0..1:* or 1:* associations and so introducing a referential constraint would cause validation errors. // Must use Referential Constraint for 1:0..1 relationship as using an AssociationSetMapping results in illegal reference to the same ID column twice (since the PK is also the FK) if (Association.IsOneToZeroOrOne || (UseReferentialConstraint && !(Association.IsZeroOrOneToZeroOrOne || Association.IsOneToOne))) { // We're including fk columns, so the update will consist of a ref constraint var createRefConCommand = new CreateOrUpdateReferentialConstraintCommand( (c, subCpc) => { var cmd = c as CreateOrUpdateReferentialConstraintCommand; cmd.PrincipalEnd = PrincipalEnd; cmd.DependentEnd = DependentEnd; cmd.PrincipalProperties = PrincipalProperties; cmd.DependentProperties = DependentProperties; return(cmd.PrincipalEnd != null && cmd.DependentEnd != null); }); CommandProcessor.InvokeSingleCommand(cpc, createRefConCommand); } else { // We're not including fk columns, so the update will consist of an association set mapping and a deletes of the fk columns (if they exist) // otherwise update AssociationSetMapping appropriately var createMapCommand = new CreateOrUpdateAssociationSetMappingCommand( (c, subCpc) => { var cmd = c as CreateOrUpdateAssociationSetMappingCommand; cmd.Association = Association; cmd.AssociationSet = AssociationSet; cmd.EntityContainerMapping = EntityContainerMapping; cmd.StorageEntitySet = StorageEntitySet; return(cmd.Association != null && cmd.AssociationSet != null && cmd.EntityContainerMapping != null && cmd.StorageEntitySet != null); }); CommandProcessor.InvokeSingleCommand(cpc, createMapCommand); // Delete the fk properties in the conceptual layer if they exist. Do not delete primary key properties though! if (!IncludeFkProperties) { var propertiesToDelete = DependentProperties.Where(p => p.EntityType != null && !p.EntityType.ResolvableKeys.Contains(p)).ToList(); foreach (var p in propertiesToDelete) { var deletePropertyCmd = new DeletePropertyCommand( (c, subCpc) => { var cmd = c as DeletePropertyCommand; cmd.EFElement = p; return(cmd.EFElement != null); }); CommandProcessor.InvokeSingleCommand(cpc, deletePropertyCmd); } } // Add or update the EndProperty elements for the AssociationSetMapping. Try to work out which end is the principal // end by looking at the multiplicity, since we don't have a referential constraint in this case. AssociationSetEnd principalSetEnd; AssociationSetEnd dependentSetEnd; Debug.Assert( AssociationSet.AssociationSetEnds().First().Role.Target != null, "Role Target for Association End was null, AssociationSetMapping update failed"); if (AssociationSet.AssociationSetEnds().First().Role.Target != null) { if (Association.End1.Multiplicity.Value == ModelConstants.Multiplicity_Many) { principalSetEnd = AssociationSet.AssociationSetEnds().Last(); dependentSetEnd = AssociationSet.AssociationSetEnds().First(); } else { principalSetEnd = AssociationSet.AssociationSetEnds().First(); dependentSetEnd = AssociationSet.AssociationSetEnds().Last(); } var dependentEndPropertyCmd = new CreateOrUpdateEndPropertyCommand( (c, subCpc) => { var cmd = c as CreateOrUpdateEndPropertyCommand; cmd.AssociationSetEnd = dependentSetEnd; cmd.AssociationSetMapping = createMapCommand.AssociationSetMapping; cmd.StorageKeyProperties = StorageDependentTypeKeyProperties; cmd.ConceptualKeyProperties = ConceptualDependentType.SafeInheritedAndDeclaredProperties.Where(p => p.IsKeyProperty); return(cmd.AssociationSetEnd != null && cmd.AssociationSetMapping != null); }); var principalEndPropertyCmd = new CreateOrUpdateEndPropertyCommand( (c, subCpc) => { var cmd = c as CreateOrUpdateEndPropertyCommand; cmd.AssociationSetEnd = principalSetEnd; cmd.AssociationSetMapping = createMapCommand.AssociationSetMapping; cmd.StorageKeyProperties = StorageDependentTypeForeignKeyProperties; cmd.ConceptualKeyProperties = ConceptualPrincipalType.SafeInheritedAndDeclaredProperties.Where(p => p.IsKeyProperty); return(cmd.AssociationSetEnd != null && cmd.AssociationSetMapping != null); }); CommandProcessor.InvokeSingleCommand(cpc, dependentEndPropertyCmd); CommandProcessor.InvokeSingleCommand(cpc, principalEndPropertyCmd); } } } }
protected CombinedNodeViewModel(GraphViewModel ownerViewModel, string name, IEnumerable <SingleNodeViewModel> combinedNodes, Index index) : base(ownerViewModel, index) { // ReSharper disable once DoNotCallOverridableMethodsInConstructor DependentProperties.Add(nameof(Value), new[] { nameof(HasMultipleValues), nameof(IsPrimitive), nameof(HasCollection), nameof(HasDictionary) }); this.combinedNodes = new List <SingleNodeViewModel>(combinedNodes); Name = name; DisplayName = this.combinedNodes.First().DisplayName; combinedNodeInitialValues = new List <object>(); distinctCombinedNodeInitialValues = new HashSet <object>(); bool isReadOnly = false; bool isVisible = false; bool nullOrder = false; foreach (var node in this.combinedNodes) { if (node.IsDestroyed) { throw new InvalidOperationException("One of the combined node is already disposed."); } if (node.IsReadOnly) { isReadOnly = true; } if (node.IsVisible) { isVisible = true; } if (node.Order == null) { nullOrder = true; } if (order == node.Order || (!nullOrder && order == null)) { order = node.Order; } // Note: sometimes member info could be different for the same member if we select objects of types that inherit from another // This will just affect the view order, so it shouldn't be a problem. if (memberInfo == null) { memberInfo = node.MemberInfo; } combinedNodeInitialValues.Add(node.Value); distinctCombinedNodeInitialValues.Add(node.Value); } IsReadOnly = isReadOnly; IsVisible = isVisible; ResetInitialValues = new AnonymousCommand(ServiceProvider, () => { using (Owner.BeginCombinedAction(Owner.FormatCombinedUpdateMessage(this, null), Path)) { CombinedNodes.Zip(combinedNodeInitialValues).ForEach(x => x.Item1.Value = x.Item2); Refresh(); } }); }
private DragContainer() { DependentProperties.Add(nameof(IsAccepted), new[] { nameof(IsRejected) }); }