public static PropertyChangedListener ListenForPropertyChanged(this INotifyPropertyChanged target, params string[] properties) { var listener = new PropertyChangedListener(properties); listener.Subscribe(target); return(listener); }
protected override void Arrange() { base.Arrange(); ApplicationModel = Container.Resolve <ApplicationViewModel>(); ApplicationModelChangedListener = new PropertyChangedListener(ApplicationModel); }
public void IDataContainer_ShouldRaisePropertyChangedForNestedContainers() { IDataContainer A = DataContainerBuilder.Create("A") .Data("A", 1) .Data("B", 2) .Data("C", 3) .DataContainer("AA", b => b .Data("A1", 23) .Data("A2", 24) .DataContainer("AAA", b => b .Data("AA1", 3))) .Build(); var listener = new PropertyChangedListener(A); A["A"] = 55; Assert.Equal("A", listener.LastChangedProperty); Assert.Single(listener.PropertiesChanged); IDataContainer AA = (IDataContainer)A["AA"]; AA["A2"] = 42; Assert.Equal("AA.A2", listener.LastChangedProperty); Assert.Equal(2, listener.PropertiesChanged.Count); IDataContainer AAA = (IDataContainer)AA["AAA"]; AAA["AA1"] = 5; Assert.Equal("AA.AAA.AA1", listener.LastChangedProperty); Assert.Equal(3, listener.PropertiesChanged.Count); }
public void IDataContainer_ShouldRaisePropertyChanged() { IDataContainer A = DataContainerBuilder.Create("A") .Data("A", 1) .Data("B", 2) .Data("C", 3) .Build(); var listener = new PropertyChangedListener(A); A["A"] = 55; Assert.Equal("A", listener.LastChangedProperty); Assert.Single(listener.PropertiesChanged); A["B"] = 23; Assert.Equal("B", listener.LastChangedProperty); Assert.Equal(2, listener.PropertiesChanged.Count); A["C"] = 29; Assert.Equal("C", listener.LastChangedProperty); Assert.Equal(3, listener.PropertiesChanged.Count); Assert.Contains("A", listener.PropertiesChanged); Assert.Contains("B", listener.PropertiesChanged); Assert.Contains("C", listener.PropertiesChanged); }
protected override void Arrange() { base.Arrange(); requiredReferenceingProperty = this.SectionViewModel.Property("RequiredReferenceItem"); requiredReferenceingProperty.Value = "FirstItem"; propertyChangeListener = new PropertyChangedListener(requiredReferenceingProperty); }
protected override void Arrange() { base.Arrange(); step = Container.Resolve <PickExceptionStep>(); propertyChangedListener = new PropertyChangedListener(step); }
protected override void Act() { overridenWrapTypeProperty = base.OverridesProperty.ChildProperties.Where(x => x.PropertyName == "WrapExceptionTypeName").FirstOrDefault(); overridenWrapTypePropertyChangedListener = new PropertyChangedListener(overridenWrapTypeProperty.BindableProperty); OverridesProperty.Value = OverridesProperty.Converter.ConvertFromString(OverridesProperty, "Override Properties"); }
protected override void Arrange() { base.Arrange(); var section = new ElementForValidation(); sectionModel = SectionViewModel.CreateSection(Container, "mock section", section); validationResult = new ElementValidationResult(sectionModel, "TestMessage", true); listener = new PropertyChangedListener(validationResult); }
public void then_overridden_value_changed_if_main_is_changed() { using (PropertyChangedListener listener = new PropertyChangedListener(OverriddenExceptionMessage)) { MainExceptionMessage.Value = "New Value"; Assert.IsTrue(listener.ChangedProperties.Contains("Value")); Assert.AreEqual("New Value", OverriddenExceptionMessage.Value); } }
protected override void Arrange() { base.Arrange(); UIServiceMock.Setup(x => x.ShowFileDialog(It.IsAny <FileDialog>())).Returns(new FileDialogResult { DialogResult = true, FileName = TestConfigurationFilePath }); UIServiceMock.Setup(x => x.ShowWindow(It.IsAny <WaitDialog>())).Verifiable("Wait dialog not displayed"); shellServiceChangedListener = new PropertyChangedListener(ApplicationModel); }
public Entity(IntPtr ptr) : base(ptr) { Parameters = new Array <Parameter>(Entity_getParameters(NativePtr), p => new Parameter(p)); propertyChangedCallback = Entity_getPropertyChangedListener(NativePtr); if (propertyChangedCallback == null) { propertyChangedCallback = new PropertyChangedListener(() => NotifyPropertyChanged()); Entity_setPropertyChangedListener(NativePtr, propertyChangedCallback); } }
protected override void Arrange() { base.Arrange(); Steps[0].SetIsValid(true); changeListener = new PropertyChangedListener(this.Wizard); commandListener = new CanExecuteChangedListener(); commandListener.Add(this.Wizard.NextCommand); commandListener.Add(this.Wizard.PreviousCommand); }
protected override void Arrange() { base.Arrange(); defaultCacheManagerProperty = (ElementReferenceProperty)CachingViewModel.Property("DefaultCacheManager"); defaultCacheManagerProperty.Initialize(null); cacheManager = CachingViewModel.GetDescendentsOfType <CacheManagerData>().First(); defaultCacheManagerPropertyChangedListener = new PropertyChangedListener(defaultCacheManagerProperty); }
protected override void Arrange() { base.Arrange(); var configurationSourceModel = Container.Resolve <ConfigurationSourceModel>(); var viewModel = configurationSourceModel.AddSection(ExceptionHandlingSettings.SectionName, Section); var loggingModel = configurationSourceModel.AddSection(LoggingSettings.SectionName, LogginSettings); var logExceptionHandler = viewModel.DescendentElements(x => x.ConfigurationType == typeof(LoggingExceptionHandlerData)).First(); logCategoryProperty = logExceptionHandler.Property("LogCategory"); logCategoryPropertyChangeListener = new PropertyChangedListener(logCategoryProperty); }
public void when_changing_name_property_on_named_element_name_property_changes() { var anyPolicy = viewModel.DescendentElements().Where(x => x.ConfigurationType == typeof(ExceptionPolicyData)).First(); var nameProperty = anyPolicy.Property("Name"); string name = anyPolicy.Name; using (PropertyChangedListener listener = new PropertyChangedListener(anyPolicy)) { nameProperty.Value = "new value"; Assert.IsTrue(listener.ChangedProperties.Contains("Name")); } }
protected override void Arrange() { base.Arrange(); deepestRule = ValidationViewModel.DescendentConfigurationsOfType <AndCompositeValidatorData>() .Where(x => string.Equals(x.NameProperty.Value, DeepestRuleValidatorName)).First(); walker = new ElementListLayoutWalker(Layout.Contained); var currentDeepestLayout = walker.LayoutElements().OfType <TwoColumnsLayout>().Where(l => l.Left == deepestRule).First(); var layoutHeader = FindHorizontalList(currentDeepestLayout.ColumnName); propertyChangedListener = new PropertyChangedListener(layoutHeader); }
public void when_changing_name_path_changes() { var anyPolicy = viewModel.DescendentElements().Where(x => x.ConfigurationType == typeof(ExceptionPolicyData)).First(); string name = anyPolicy.Name; using (var propListener = new PropertyChangedListener(anyPolicy)) { anyPolicy.Property("Name").Value = "new name"; Assert.IsTrue(propListener.ChangedProperties.Contains("Path")); } }
internal void ListenPropertyChange(BindableProperty bindableProperty, PropertyChangedEventHandler eventHandler) { PropertyChangedListener propertyChangedListener; BindablePropertyChangedEventDict.TryGetValue(bindableProperty.PropertyName, out propertyChangedListener); if (null == propertyChangedListener) { propertyChangedListener = new PropertyChangedListener(); BindablePropertyChangedEventDict.Add(bindableProperty.PropertyName, propertyChangedListener); } propertyChangedListener.RegisterListnerHandler(eventHandler); }
internal static IPropertyChangedListener ListenToChanged(DependencyObject target, DependencyProperty property, Action <object, IDependencyPropertyChangedEventArgs> updateSourceCallback) { var storage = GetStorageOrCreateNewIfNotExists(target, property); List <IPropertyChangedListener> listeners = storage.PropertyListeners; if (listeners == null) { listeners = storage.PropertyListeners = new List <IPropertyChangedListener>(); } PropertyChangedListener listener = new PropertyChangedListener(storage, updateSourceCallback); listeners.Add(listener); return(listener); }
protected override void Arrange() { base.Arrange(); var sourceModel = Container.Resolve <ConfigurationSourceModel>(); LoggingViewModel = sourceModel.AddSection(LoggingSettings.SectionName, LoggingSection); defaultCategoryProperty = (ElementReferenceProperty)LoggingViewModel.Property("DefaultCategory"); defaultCategoryProperty.Initialize(null); traceSource = LoggingViewModel.GetDescendentsOfType <TraceSourceData>().First(); defaultCacheManagerPropertyChangedListener = new PropertyChangedListener(defaultCategoryProperty); }
/// <summary> /// Initializes a new instance of the <see cref="GroupingCollection"/> class. /// </summary> /// <param name="enumerable">The input sequence.</param> /// <param name="grouping">The underlying grouping.</param> internal GroupingCollection(IEnumerable <DependencyObject> enumerable, Grouping grouping) : this(new RecomposableCollection <DependencyObject>(grouping.GroupSort(enumerable))) { this.grouping = grouping; propertyListener = new PropertyChangedListener(this); PropertyChangedEvent.AddListener(grouping, propertyListener); if (enumerable is INotifyCollectionChanged collection) { this.enumerable = enumerable; collectionListener = new CollectionChangedListener(this); CollectionChangedEvent.AddListener(collection, collectionListener); } }
/// <summary> /// Initializes a new instance of the <see cref="ContainerCollection"/> class. /// </summary> /// <param name="items">The input data objects.</param> /// <param name="converter">The underlying converter.</param> internal ContainerCollection(IList items, ItemsConverter converter) : this(new ObservableCollection <DependencyObject>(converter.GetContainers(items))) { this.converter = converter; propertyListener = new PropertyChangedListener(this); PropertyChangedEvent.AddListener(converter, propertyListener); if (items is INotifyCollectionChanged collection) { this.items = items; collectionListener = new CollectionChangedListener(this); CollectionChangedEvent.AddListener(collection, collectionListener); } }
internal static IPropertyChangedListener ListenToChanged(DependencyObject target, DependencyProperty property, Action <object, IDependencyPropertyChangedEventArgs> updateSourceCallback) { INTERNAL_PropertyStorage storage; TryGetStorage(target, property, true /*create*/, out storage); List <IPropertyChangedListener> listeners = storage.PropertyListeners; if (listeners == null) { listeners = storage.PropertyListeners = new List <IPropertyChangedListener>(); } PropertyChangedListener listener = new PropertyChangedListener(storage, updateSourceCallback); listeners.Add(listener); return(listener); }
protected override void Act() { firstHandler = ViewModel.DescendentElements(x => x.ConfigurationType == typeof(TestHandlerData)).OfType <CollectionElementViewModel>() .Where(x => x.Name == "One").Single(); firstHandler.Select(); firstElementChangeListener = new PropertyChangedListener(firstHandler); secondHandler = ViewModel.DescendentElements(x => x.ConfigurationType == typeof(TestHandlerData)).OfType <CollectionElementViewModel>() .Where(x => x.Name == "Two").Single(); secondHandler.MoveUp.Execute(null); }
public void IDataContainer_ShouldNotRaisePropertyChangedIfValueSame() { IDataContainer A = DataContainerBuilder.Create("A") .Data("A", 1) .Data("B", 2) .Data("C", 3) .Build(); var listener = new PropertyChangedListener(A); A["A"] = 1; Assert.True(string.IsNullOrEmpty(listener.LastChangedProperty)); Assert.Empty(listener.PropertiesChanged); A["A"] = 2; Assert.Equal("A", listener.LastChangedProperty); Assert.NotEmpty(listener.PropertiesChanged); }
public void IDataContainer_ObjectDataObjectRaisesPropertyChangedWhenCLRObjectChanges() { BindingTestObject obj = new BindingTestObject(); IDataContainer A = DataContainerBuilder.Create("A") .Data("Obj1", obj, SerializationFormat.Container) .Data("Obj2", obj, SerializationFormat.Xml) .Data("Obj3", obj, SerializationFormat.Json) .Build(); var listener = new PropertyChangedListener(A); obj.IntProperty = 44; Assert.Contains("Obj1", listener.PropertiesChanged); Assert.Contains("Obj2", listener.PropertiesChanged); Assert.Contains("Obj3", listener.PropertiesChanged); Assert.Equal("Obj3", listener.LastChangedProperty); }
public void IDataContainer_EnableChangeNotificationWorks() { IDataContainer A = DataContainerBuilder.Create("A") .Data("A", 1) .Data("B", 2) .Data("C", 3) .Build(); A.EnableChangeNotification = false; var listener = new PropertyChangedListener(A); A["A"] = 55; Assert.Null(listener.LastChangedProperty); Assert.Empty(listener.PropertiesChanged); A.EnableChangeNotification = true; A["B"] = 23; Assert.Equal("B", listener.LastChangedProperty); Assert.Single(listener.PropertiesChanged); }
public void IDataContainer_RefreshUpdatesChangedValue() { IDataContainer A = DataContainerBuilder.Create() .Data("A", 2) .Data("B", 3) .Data("C", 4) .Build(); IDataContainer A2 = DataContainerBuilder.Create() .Data("A", 2) .Data("B", 3) .Data("C", 5) .Build(); var listener = new PropertyChangedListener(A); Assert.NotEqual(A["C"], A2["C"]); A.Refresh(A2); Assert.Equal(A["C"], A2["C"]); Assert.Equal("C", listener.LastChangedProperty); Assert.Single(listener.PropertiesChanged); }
protected override void Arrange() { base.Arrange(); applicationModelChangedListener = new PropertyChangedListener(base.ApplicationModel); }
protected override void Arrange() { base.Arrange(); propertyPropertyChangedListener = new PropertyChangedListener(base.property.BindableProperty); }