public OverviewMapController(MapView overview) { _insetView = overview; _extentOverlay = new GraphicsOverlay(); if (_insetView.GraphicsOverlays == null) { _insetView.GraphicsOverlays = new GraphicsOverlayCollection(); } _insetView.GraphicsOverlays.Add(_extentOverlay); _extentGraphic = new Graphic(); _extentOverlay.Graphics.Add(_extentGraphic); // _overview.ViewpointChanged += OnViewpointChanged _viewpointListener = new WeakEventListener <GeoView, object?, EventArgs>(_insetView) { OnEventAction = (instance, source, eventArgs) => OnInsetViewpointChanged(source, eventArgs), OnDetachAction = (instance, weakEventListener) => instance.ViewpointChanged -= weakEventListener.OnEvent, }; _insetView.ViewpointChanged += _viewpointListener.OnEvent; // _overview.NavigationCompleted += OnNavigationCompleted; _navigationListener = new WeakEventListener <GeoView, object?, EventArgs>(_insetView) { OnEventAction = (instance, source, eventArgs) => OnInsetNavigationCompleted(source, eventArgs), OnDetachAction = (instance, weakEventListener) => instance.NavigationCompleted -= weakEventListener.OnEvent, }; _insetView.NavigationCompleted += _navigationListener.OnEvent; }
private void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue) { // Remove handler for oldValue.CollectionChanged (if present) INotifyCollectionChanged oldValueINotifyCollectionChanged = oldValue as INotifyCollectionChanged; if (null != oldValueINotifyCollectionChanged && null != _collectionChangedWeakEventListener) { _collectionChangedWeakEventListener.Detach(); _collectionChangedWeakEventListener = null; } // Add handler for newValue.CollectionChanged (if possible) INotifyCollectionChanged newValueINotifyCollectionChanged = newValue as INotifyCollectionChanged; if (null != newValueINotifyCollectionChanged) { _collectionChangedWeakEventListener = new WeakEventListener <MultiCircleChart, object, NotifyCollectionChangedEventArgs>(this); _collectionChangedWeakEventListener.OnEventAction = (instance, source, eventArgs) => instance.ItemsSourceCollectionChanged(source, eventArgs); _collectionChangedWeakEventListener.OnDetachAction = (weakEventListener) => newValueINotifyCollectionChanged.CollectionChanged -= weakEventListener.OnEvent; newValueINotifyCollectionChanged.CollectionChanged += _collectionChangedWeakEventListener.OnEvent; } // Store a local cached copy of the data _items = newValue == null ? null : new List <object>(newValue.Cast <object>().ToList()); //// Clear and set the view on the selection adapter RefreshView(); }
public SpreadsheetCellDataFieldViewModel(Type viewModelType, PropertyInfo propertyInfo, IEditableProxy model, DetailsViewModel parentViewModel, IColumnItem column) { _propertyInfo = propertyInfo; _parentModel = model; if (_parentModel != null) { var parentModelBO = _parentModel as BusinessBase; if (parentModelBO != null) { var weakListener = new WeakEventListener<SpreadsheetCellDataFieldViewModel, BusinessBase, PropertyChangedEventArgs>(this, parentModelBO); parentModelBO.PropertyChanged += weakListener.OnEvent; weakListener.OnEventAction += OnParentModelPropertyChanged; weakListener.OnDetachAction += Static; } _allProperties = _parentModel.GetAllPropertiesForInstance(); var root = _parentModel.GetModel(); if (root != null) _allMasterProperties = root.GetAllPropertiesForInstance(); } _parentDetailsVM = parentViewModel; _fieldViewModelType = viewModelType; _column = column; }
public CollectionView(IEnumerable collection) { _sourceCollection = collection ?? throw new ArgumentNullException("collection"); // forward collection change events from underlying collection to our listeners. INotifyCollectionChanged incc = collection as INotifyCollectionChanged; if (incc != null) { _sourceWeakEventListener = new WeakEventListener <CollectionView, object, NotifyCollectionChangedEventArgs>(this) { // Call the actual collection changed event OnEventAction = (source, changed, arg) => OnCollectionChanged(source, arg), // The source doesn't exist anymore OnDetachAction = (listener) => incc.CollectionChanged -= _sourceWeakEventListener.OnEvent }; incc.CollectionChanged += _sourceWeakEventListener.OnEvent; } _currentItem = null; _currentPosition = -1; SetFlag(CollectionViewFlags.IsCurrentBeforeFirst, _currentPosition < 0); SetFlag(CollectionViewFlags.IsCurrentAfterLast, _currentPosition < 0); SetFlag(CollectionViewFlags.CachedIsEmpty, _currentPosition < 0); }
private static void AttachObservableModelCallback(DependencyObject source, DependencyPropertyChangedEventArgs args) { var typeName = args.NewValue as string; var view = source as FrameworkElement; if (typeName == null || view == null) return; var modelType = Type.GetType("Raven.Studio.Models." + typeName) ?? Type.GetType(typeName); if (modelType == null) return; try { var model = (Model)Activator.CreateInstance(modelType); model.ForceTimerTicked(); var observable = (IObservable)Activator.CreateInstance(typeof(Observable<>).MakeGenericType(modelType)); observable.Value = model; view.DataContext = observable; SetPageTitle(model, view); var weakListener = new WeakEventListener<IObservable, object, RoutedEventArgs>(observable); view.Loaded += weakListener.OnEvent; weakListener.OnEventAction = OnViewLoaded; weakListener.OnDetachAction = listener => view.Loaded -= listener.OnEvent; } catch (Exception ex) { throw new InvalidOperationException(string.Format("Cannot create instance of model type: {0}", modelType), ex); } }
public TransitMap() { this.InitializeComponent(); MainMap.MapServiceToken = Keys.BingMapKey; CenterConverter.Add(new LatLonTransformConverter() { Transform = ll => CenterOffset.IsNotALocation ? ll : ll + CenterOffset, ReverseTransform = ll => CenterOffset.IsNotALocation ? ll : ll - CenterOffset }); CenterConverter.Add(LatLonToGeopointConverter.Instance); WeakEventListener <TransitMap, object, NotifyCollectionChangedEventArgs> addInsListener = new WeakEventListener <TransitMap, object, NotifyCollectionChangedEventArgs>(this); addInsListener.OnEventAction = (map, obj, e) => map.AddIns_CollectionChanged(obj, e); AddIns.CollectionChanged += addInsListener.OnEvent; MapRouteBindings = new CompositeCollectionBinding <MapRouteView, TransitMapAddInBase>(MainMap.Routes); MapElementBindings = new CompositeCollectionBinding <MapElement, TransitMapAddInBase>(MainMap.MapElements); MapChildrenBindings = new CompositeCollectionBinding <DependencyObject, TransitMapAddInBase>(MainMap.Children); //MainMap.SetBinding(MapControl.CenterProperty, new Binding() { Converter = CenterConverters, Source = this, Path = new PropertyPath("Center"), Mode = BindingMode.TwoWay }); //MainMap.SetBinding(MapControl.ZoomLevelProperty, new Binding() { Source = this, Path = new PropertyPath("ZoomLevel"), Mode = BindingMode.TwoWay }); //MapIcon centerIndicator = new MapIcon() { NormalizedAnchorPoint = new Point(0.5, 1) }; //BindingOperations.SetBinding(centerIndicator, MapIcon.LocationProperty, new Binding() { Source = this, Path = new PropertyPath("Center"), Converter = LatLonToGeopointConverter.Instance }); //MainMap.MapElements.Add(centerIndicator); }
private static void Detach([NotNull] WeakEventListener <ObservableFilteredCollection <T>, INotifyCollectionChanged, NotifyCollectionChangedEventArgs> weakEvent, [NotNull] INotifyCollectionChanged sender) { Contract.Requires(weakEvent != null); Contract.Requires(sender != null); sender.CollectionChanged -= weakEvent.OnEvent; }
private void AttachLayersHandler(IEnumerable <Layer> layers) { if (layers != null) { // Subscribe to Layers Collection changes var layersINotifyCollectionChanged = layers as INotifyCollectionChanged; if (layersINotifyCollectionChanged != null) { Debug.Assert(_layersWeakEventListener == null); _layersWeakEventListener = new WeakEventListener <TemplatePicker, object, NotifyCollectionChangedEventArgs>(this) { OnEventAction = (instance, source, eventArgs) => instance.OnLayerCollectionChanged(source, eventArgs), OnDetachAction = weakEventListener => layersINotifyCollectionChanged.CollectionChanged -= weakEventListener.OnEvent }; layersINotifyCollectionChanged.CollectionChanged += _layersWeakEventListener.OnEvent; } // Subscribe to FeatureLayers Property Changes Debug.Assert(_featureLayerPropertyChangedListeners == null); _featureLayerPropertyChangedListeners = new DependencyPropertyChangedListeners <TemplatePicker>(this) { OnEventAction = (instance, source, eventArgs) => instance.OnLayerPropertyChanged(source, eventArgs) }; foreach (var layer in layers.OfType <FeatureLayer>()) { AttachLayerHandler(layer); } } }
private static void Attach([NotNull] WeakEventListener <ObservableWrappedCollection <TSource, TTarget>, INotifyCollectionChanged, NotifyCollectionChangedEventArgs> weakEvent, [NotNull] INotifyCollectionChanged sender) { Contract.Requires(weakEvent != null); Contract.Requires(sender != null); sender.CollectionChanged += weakEvent.OnEvent; }
public void DoesNotLeakWithActionsDefinedInDisplayClass() { var source = new EventSource(); var counter = 0; Action action = () => { counter++; }; var weakEventListener = WeakEventListener.SubscribeToWeakEvent(this, source, "PublicEvent", action); Assert.AreEqual(0, counter); source.RaisePublicEvent(); Assert.AreEqual(1, counter); // Some dummy code to make sure the previous listener is removed GC.Collect(); //Assert.IsTrue(weakEventListener.IsSourceAlive); //Assert.IsFalse(weakEventListener.IsTargetAlive); // Some dummy code to make sure the source stays in memory source.GetType(); }
public virtual void Initialize(ChecklistSingleViewModel parentVM, IFieldDefinitionEntity fieldDef, IEventAggregator eventAggregator) { _eventAggregator = eventAggregator; _process = (TemplateEntity)parentVM.QuestionsTemplate; _parentVM = parentVM; _fieldDefinition = fieldDef; ChangeChartTypeCommand = new DelegateCommand(ExecuteChange); PrepareFieldDefRelatedData(); var weakListener = new WeakEventListener<SPCChartControlViewModel, ChecklistViewModelBase, EventArgs>(this, parentVM); parentVM.SelectesQuestionChanged += weakListener.OnEvent; weakListener.OnEventAction = OnSelectedQuestionChanged; weakListener.OnDetachAction = (listener, source) => { source.SelectesQuestionChanged -= listener.OnEvent; }; ShowLCLAnyChart = true; ShowUCLAnyChart = true; ShowMeanAnyChart = true; ShowLCLRangeChart = true; ShowUCLRangeChart = true; ShowMeanRangeChart = true; ShowUSL = false; ShowLSL = false; OnSelectedQuestionChanged(this, parentVM, EventArgs.Empty); }
public void AfterListenerIsNull_EventDetaching() { WasDetached = false; EventCounter = 0; var list = new ObservableCollection<int>(); WeakEventListener<object, ObservableCollection<int>, EventArgs> weakEventListener = null; var obj = new object(); weakEventListener = new WeakEventListener<object, ObservableCollection<int>, EventArgs>(obj, list); list.CollectionChanged += weakEventListener.OnEvent; weakEventListener.OnEventAction += (o, o1, arg3) => { EventCounter++; }; weakEventListener.OnDetachAction += (listener, source) => { source.CollectionChanged -= listener.OnEvent; WasDetached = true; }; list.Add(1); obj = null; GC.Collect(); list.Add(2); GC.Collect(); Assert.IsTrue(WasDetached); Assert.AreEqual(EventCounter, 1); }
/// <summary> /// Called when the value of the ItemsSourceProperty property changes. /// </summary> /// <param name="oldValue">The old ItemsSource collection.</param> /// <param name="newValue">The new ItemsSource collection.</param> protected virtual void OnItemsSourcePropertyChanged(IEnumerable oldValue, IEnumerable newValue) { // Remove handler for oldValue.CollectionChanged (if present) INotifyCollectionChanged oldValueINotifyCollectionChanged = oldValue as INotifyCollectionChanged; if (null != oldValueINotifyCollectionChanged) { // Detach the WeakEventListener if (null != _weakEventListener) { _weakEventListener.Detach(); _weakEventListener = null; } } // Add handler for newValue.CollectionChanged (if possible) INotifyCollectionChanged newValueINotifyCollectionChanged = newValue as INotifyCollectionChanged; if (null != newValueINotifyCollectionChanged) { // Use a WeakEventListener so that the backwards reference doesn't keep this object alive _weakEventListener = new WeakEventListener <TreeMap, object, NotifyCollectionChangedEventArgs>(this); _weakEventListener.OnEventAction = (instance, source, eventArgs) => instance.ItemsSourceCollectionChanged(source, eventArgs); _weakEventListener.OnDetachAction = (weakEventListener) => newValueINotifyCollectionChanged.CollectionChanged -= weakEventListener.OnEvent; newValueINotifyCollectionChanged.CollectionChanged += _weakEventListener.OnEvent; } // Handle property change RebuildTree(); }
private static void Detach([NotNull] WeakEventListener <ObservableSelectImpl <TSource, TTarget>, INotifyPropertyChanged, PropertyChangedEventArgs> weakEvent, [NotNull] INotifyPropertyChanged sender) { Contract.Requires(weakEvent != null); Contract.Requires(sender != null); sender.PropertyChanged -= weakEvent.OnEvent; }
private void OnCollectionChanged(object oldValue, object newValue) { if (oldValue is INotifyCollectionChanged) { var incc = (INotifyCollectionChanged)oldValue; incc.CollectionChanged -= Incc_CollectionChanged; _inccWeakEventListener?.Detach(); _inccWeakEventListener = null; } if (newValue is IEnumerable) { if (newValue is INotifyCollectionChanged) { var incc = (INotifyCollectionChanged)newValue; _inccWeakEventListener = new WeakEventListener <RotatorTile, object, NotifyCollectionChangedEventArgs>(this) { OnEventAction = (instance, source, eventArgs) => instance.Incc_CollectionChanged(source, eventArgs), OnDetachAction = (listener) => incc.CollectionChanged -= listener.OnEvent }; incc.CollectionChanged += _inccWeakEventListener.OnEvent; } Start(); } else { _timer?.Stop(); } }
/// <summary> /// Handles changes to the ItemsSource property. /// </summary> /// <param name="oldValue">Old value.</param> /// <param name="newValue">New value.</param> private void OnItemsSourceChanged(IEnumerable oldValue, IEnumerable newValue) { // Remove handler for oldValue.CollectionChanged (if present) INotifyCollectionChanged oldValueINotifyCollectionChanged = oldValue as INotifyCollectionChanged; if (null != oldValueINotifyCollectionChanged) { // Detach the WeakEventListener if (null != _weakEventListener) { _weakEventListener.Detach(); _weakEventListener = null; } } // Add handler for newValue.CollectionChanged (if possible) INotifyCollectionChanged newValueINotifyCollectionChanged = newValue as INotifyCollectionChanged; if (null != newValueINotifyCollectionChanged) { // Use a WeakEventListener so that the backwards reference doesn't keep this object alive _weakEventListener = new WeakEventListener <SeriesDefinition, object, NotifyCollectionChangedEventArgs>(this); _weakEventListener.OnEventAction = (instance, source, eventArgs) => instance.ItemsSourceCollectionChanged(source, eventArgs); _weakEventListener.OnDetachAction = (weakEventListener) => newValueINotifyCollectionChanged.CollectionChanged -= weakEventListener.OnEvent; newValueINotifyCollectionChanged.CollectionChanged += _weakEventListener.OnEvent; } if (null != ParentDefinitionSeries) { ParentDefinitionSeries.SeriesDefinitionItemsSourceChanged(this, oldValue, newValue); } }
private void Handler() { var propertyChangedListener = new WeakEventListener<PopUpSearchView, ListBox, SelectionChangedEventArgs>(this, ListBoxItems); ListBoxItems.SelectionChanged += propertyChangedListener.OnEvent; propertyChangedListener.OnEventAction += ValuePropertyChanged; propertyChangedListener.OnDetachAction += Static; }
private void DetachDisposedListener() { if (_disposedListener != null) { _disposedListener.Detach(); _disposedListener = null; } }
internal void ReleaseEvents() { if (_innerListListener is not null) { CollectionChangedEventManager.RemoveListener((INotifyCollectionChanged)_innerList, _innerListListener); _innerListListener = null; } }
private void UnregisterSelectedStopsSourceHandlers(ObservableCollection <TransitStop> collection) { if (SelectedStopsSource_CollectionChanged_Listener != null) { SelectedStopsSource_CollectionChanged_Listener.Detach(); SelectedStopsSource_CollectionChanged_Listener = null; } }
internal void ReleaseEvents() { if( _innerListListener != null ) { CollectionChangedEventManager.RemoveListener( ( INotifyCollectionChanged )_innerList, _innerListListener ); _innerListListener = null; } }
/// <summary> /// Initializes a new instance of the <see cref="SelectCrossRefViewModel"/> class. /// </summary> public SelectCrossRefViewModel() { CloseOnReturn = false; var weakListener = new WeakEventListener<SelectCrossRefViewModel, ObservableCollection<object>, NotifyCollectionChangedEventArgs>(this, _selectedItems); _selectedItems.CollectionChanged += weakListener.OnEvent; weakListener.OnEventAction += SelectedItemsOnCollectionChanged; weakListener.OnDetachAction += Static; }
private void UnregisterStopsSourceHandlers(ObservableCollection <TransitStop> collection) { if (StopsSource_CollectionChanged_Listener != null) { collection.CollectionChanged -= StopsSource_CollectionChanged_Listener.OnEvent; StopsSource_CollectionChanged_Listener?.Detach(); StopsSource_CollectionChanged_Listener = null; } }
private void UnsubscribeToDpiChanged() { if (_dpiChangedWeakEventListener != null) { var dpiChangedListener = _dpiChangedWeakEventListener; _dpiChangedWeakEventListener = null; CompatUtility.ExecuteOnUIThread(dpiChangedListener.Detach, Dispatcher); } }
private static void OnValuePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { var obj = (IsNullOrEmptyStateTrigger)d; var val = e.NewValue; obj.SetActive(IsNullOrEmpty(val)); if (val == null) { return; } // Try to listen for various notification events // Starting with INorifyCollectionChanged var valNotifyCollection = val as INotifyCollectionChanged; if (valNotifyCollection != null) { var weakEvent = new WeakEventListener <INotifyCollectionChanged, object, NotifyCollectionChangedEventArgs>(valNotifyCollection) { OnEventAction = (instance, source, args) => obj.SetActive(IsNullOrEmpty(instance)), OnDetachAction = (weakEventListener) => valNotifyCollection.CollectionChanged -= weakEventListener.OnEvent }; valNotifyCollection.CollectionChanged += weakEvent.OnEvent; return; } // Not INotifyCollectionChanged, try IObservableVector var valObservableVector = val as IObservableVector <object>; if (valObservableVector != null) { var weakEvent = new WeakEventListener <IObservableVector <object>, object, IVectorChangedEventArgs>(valObservableVector) { OnEventAction = (instance, source, args) => obj.SetActive(IsNullOrEmpty(instance)), OnDetachAction = (weakEventListener) => valObservableVector.VectorChanged -= weakEventListener.OnEvent }; valObservableVector.VectorChanged += weakEvent.OnEvent; return; } // Not INotifyCollectionChanged, try IObservableMap var valObservableMap = val as IObservableMap <object, object>; if (valObservableMap != null) { var weakEvent = new WeakEventListener <IObservableMap <object, object>, object, IMapChangedEventArgs <object> >(valObservableMap) { OnEventAction = (instance, source, args) => obj.SetActive(IsNullOrEmpty(instance)), OnDetachAction = (weakEventListener) => valObservableMap.MapChanged -= weakEventListener.OnEvent }; valObservableMap.MapChanged += weakEvent.OnEvent; } }
public NetworkConnectionStateTrigger() { WeakEventListener .AttachEvent <object>( handler => NetworkInformation.NetworkStatusChanged += new NetworkStatusChangedEventHandler(handler), handler => NetworkInformation.NetworkStatusChanged -= new NetworkStatusChangedEventHandler(handler), OnNetworkStatusChanged ); }
public SearchListView() { InitializeComponent(); var dataContextChangedListener = new WeakEventListener<SearchListView, SearchListView, DependencyPropertyChangedEventArgs>(this, this); DataContextChanged += dataContextChangedListener.OnEvent; dataContextChangedListener.OnEventAction = OnDataContextChanged; dataContextChangedListener.OnDetachAction = OnDetachDataContextChanged; }
private void RegisterSelectedStopsSourceHandlers(ObservableCollection <TransitStop> collection) { if (SelectedStopsSource_CollectionChanged_Listener == null) { SelectedStopsSource_CollectionChanged_Listener = new WeakEventListener <StopDetailsPopupAddIn, object, NotifyCollectionChangedEventArgs>(this); SelectedStopsSource_CollectionChanged_Listener.OnEventAction = (listener, sender, e) => listener.SelectedStopsSource_CollectionChanged(sender, e); SelectedStopsSource_CollectionChanged_Listener.OnDetachAction = (listener) => listener.OnEventAction = null; collection.CollectionChanged += SelectedStopsSource_CollectionChanged_Listener.OnEvent; } }
private void RegisterStopsSourceHandlers(ObservableCollection <TransitStop> collection) { if (StopsSource_CollectionChanged_Listener == null) { StopsSource_CollectionChanged_Listener = new WeakEventListener <ShownStopsAddIn, object, NotifyCollectionChangedEventArgs>(this); StopsSource_CollectionChanged_Listener.OnEventAction = (addin, sender, e) => addin.StopsSource_CollectionChanged(sender, e); StopsSource_CollectionChanged_Listener.OnDetachAction = (listener) => listener.OnEventAction = null; collection.CollectionChanged += StopsSource_CollectionChanged_Listener.OnEvent; } }
protected override void OnAttached() { var _weakEventListener = new WeakEventListener <AnimatedNumberAction, object, EventArgs>(this); _weakEventListener.OnEventAction = (instance, source, eventArgs) => instance.CompositionTarget_Rendering(source, eventArgs); _weakEventListener.OnDetachAction = (weakEventListener) => CompositionTarget.Rendering -= weakEventListener.OnEvent; CompositionTarget.Rendering += _weakEventListener.OnEvent; }
public VirtualizedTreeSource(CategoryScale scale, IHierarchyVirtualizationHelper virtualizer) { this._root = (Category) new ShadowCategory(); this._scale = scale; this._virtualizer = virtualizer; this._leavesChangedWeakEventListener = new WeakEventListener <CategoryScale.VirtualizedTreeSource, object, EventArgs>(this); this._leavesChangedWeakEventListener.OnEventAction = (Action <CategoryScale.VirtualizedTreeSource, object, EventArgs>)((instance, source, eventArgs) => instance.OnVirtualizerLeavesChanged(source, eventArgs)); this._leavesChangedWeakEventListener.OnDetachAction = (Action <WeakEventListener <CategoryScale.VirtualizedTreeSource, object, EventArgs> >)(weakEventListener => this._virtualizer.LeavesChanged -= new EventHandler(weakEventListener.OnEvent)); this._virtualizer.LeavesChanged += new EventHandler(this._leavesChangedWeakEventListener.OnEvent); }
public WeakCollectionChangedWrapper( IList sourceList ) { _innerList = sourceList; var notifyList = _innerList as INotifyCollectionChanged; if( notifyList != null ) { _innerListListener = new WeakEventListener<NotifyCollectionChangedEventArgs>( OnInnerCollectionChanged ); CollectionChangedEventManager.AddListener( notifyList, _innerListListener ); } }
public ResolveDatabaseObjectsViewModel() { DatabaseObjectList = new ObservableCollection<DatabaseObject>(); var weakEventListener = new WeakEventListener<object, ObservableCollection<DatabaseObject>, EventArgs>(this, DatabaseObjectList); DatabaseObjectList.CollectionChanged += weakEventListener.OnEvent; weakEventListener.OnEventAction += RaiseChanges; weakEventListener.OnDetachAction += Static; }
public void DoesNotLeakWithStaticEventHandlers() { var source = new EventSource(); var weakEventListener = WeakEventListener <EventListener, EventSource, ViewModelClosedEventArgs> .SubscribeToWeakGenericEvent(null, source, "PublicEvent", EventListener.OnEventStaticHandler); Assert.IsTrue(weakEventListener.IsSourceAlive); Assert.IsFalse(weakEventListener.IsStaticEvent); Assert.IsFalse(weakEventListener.IsTargetAlive); Assert.IsTrue(weakEventListener.IsStaticEventHandler); }
void SubscribeClickEvent(UIElement element) { if (element is FrontpageItemButton btn && !btn.ClickEventAttached) { WeakEventListener <Button, object, RoutedEventArgs> itemClickListener = new WeakEventListener <Button, object, RoutedEventArgs>(btn); itemClickListener.OnEventAction = (_, source, args) => ItemClicked?.Invoke(source, args); btn.Click += itemClickListener.OnEvent; btn.ClickEventAttached = true; } }
public WeakCollectionChangedWrapper(IList sourceList) { _innerList = sourceList; var notifyList = _innerList as INotifyCollectionChanged; if (notifyList is not null) { _innerListListener = new WeakEventListener <NotifyCollectionChangedEventArgs>(OnInnerCollectionChanged); CollectionChangedEventManager.AddListener(notifyList, _innerListListener); } }
public override void OnApplyTemplate() { base.OnApplyTemplate(); KeyboardLayoutVisualStateGroup = GetTemplateChild(VisualStateGroupKeyboardLayoutName) as VisualStateGroup; QuertyVisualState = GetTemplateChild(VisualStateQuertyName) as VisualState; NumericVisualState = GetTemplateChild(VisualStateNumericName) as VisualState; foreach (var partName in TemplatePartNames.Keys) { var element = GetTemplateChild(partName) as Button; if (element != null) { element.Command = KeyStrokeCommand; element.CommandParameter = TemplatePartNames[partName]; element.Content = TemplatePartNames[partName].Name; //element.TouchUp += new EventHandler<TouchEventArgs>(Button_TouchUp); var touchUpEventListener = new WeakEventListener <QuertyKeyboard, object, TouchEventArgs>(this); touchUpEventListener.OnEventAction = (instance, source, eventArgs) => instance.OnButtonTouchUp(source, eventArgs); touchUpEventListener.OnDetachAction = (weakEventListenerParameter) => element.TouchUp -= weakEventListenerParameter.OnEvent; element.TouchUp += touchUpEventListener.OnEvent; var touchDownEventListener = new WeakEventListener <QuertyKeyboard, object, TouchEventArgs>(this); touchDownEventListener.OnEventAction = (instance, source, eventArgs) => instance.OnButtonTouchDown(source, eventArgs); touchDownEventListener.OnDetachAction = (weakEventListenerParameter) => element.TouchDown -= weakEventListenerParameter.OnEvent; element.TouchDown += touchDownEventListener.OnEvent; //element.Click += new RoutedEventHandler(Button_Click); //var clickEventListener = new WeakEventListener<QuertyKeyboard, object, RoutedEventArgs>(this); //clickEventListener.OnEventAction = (instance, source, eventArgs) => instance.OnButtonClicked(source, eventArgs); //clickEventListener.OnDetachAction = (weakEventListenerParameter) => element.Click -= weakEventListenerParameter.OnEvent; //element.Click += clickEventListener.OnEvent; var mouseDownEventListener = new WeakEventListener <QuertyKeyboard, object, MouseButtonEventArgs>(this); mouseDownEventListener.OnEventAction = (instance, source, eventArgs) => instance.OnButtonMouseDown(source, eventArgs); mouseDownEventListener.OnDetachAction = (weakEventListenerParameter) => element.MouseDown -= weakEventListenerParameter.OnEvent; element.PreviewMouseDown += mouseDownEventListener.OnEvent; var mouseUpEventListener = new WeakEventListener <QuertyKeyboard, object, MouseButtonEventArgs>(this); mouseUpEventListener.OnEventAction = (instance, source, eventArgs) => instance.OnButtonMouseUp(source, eventArgs); mouseUpEventListener.OnDetachAction = (weakEventListenerParameter) => element.MouseUp -= weakEventListenerParameter.OnEvent; element.PreviewMouseUp += mouseUpEventListener.OnEvent; } #if DEBUG else { System.Diagnostics.Debug.WriteLine(string.Format("Part not found: {0}", partName)); } #endif OnShowCapitalize(); //OnShiftPressed(); } }
/// <summary> /// Initializes a new instance of the <see cref="NetworkConnectionStateTrigger"/> class. /// </summary> public NetworkConnectionStateTrigger() { var weakEvent = new WeakEventListener<NetworkConnectionStateTrigger, object>(this) { OnEventAction = (instance, source) => NetworkInformation_NetworkStatusChanged(source), OnDetachAction = (instance, weakEventListener) => NetworkInformation.NetworkStatusChanged -= weakEventListener.OnEvent }; NetworkInformation.NetworkStatusChanged += weakEvent.OnEvent; UpdateState(); }
public DiagramView() { InitializeComponent(); KeyDown += DiagramPanel_KeyDown; var weakListener = new WeakEventListener<DiagramView, DiagramView, RoutedEventArgs>(this, this); this.Loaded += weakListener.OnEvent; weakListener.OnEventAction += OnDiagramViewLoaded; weakListener.OnDetachAction += Static; }
public void HandleWeakEvent() { Dummy dummy = new Dummy(); bool weakEventReceived = false; var listener = new WeakEventListener<PropertyChangedEventArgs>((sender, eventArgs) => weakEventReceived = true); PropertyChangedEventManager.AddListener(dummy, listener, String.Empty); dummy.RaisePropertyChanged(); Assert.IsTrue(weakEventReceived); weakEventReceived = false; }
public ScrollOnTouchAction() { //CompositionTarget.Rendering += new EventHandler(CompositionTarget_Rendering); var renderingEventListener = new WeakEventListener <ScrollOnTouchAction, object, EventArgs>(this); renderingEventListener.OnEventAction = (instance, source, eventArgs) => instance.CompositionTarget_Rendering(source, eventArgs); renderingEventListener.OnDetachAction = (weakEventListenerParameter) => CompositionTarget.Rendering -= weakEventListenerParameter.OnEvent; CompositionTarget.Rendering += renderingEventListener.OnEvent; }
public void HandleWeakEvent() { Dummy dummy = new Dummy(); bool weakEventReceived = false; var listener = new WeakEventListener <PropertyChangedEventArgs>((sender, eventArgs) => weakEventReceived = true); PropertyChangedEventManager.AddListener(dummy, listener, String.Empty); dummy.RaisePropertyChanged(); Assert.IsTrue(weakEventReceived); weakEventReceived = false; }
public MessageListener(InteractionMessenger messenger) { Dispatcher = Dispatcher.CurrentDispatcher; _source = new WeakReference <InteractionMessenger>(messenger); _listener = new WeakEventListener <EventHandler <InteractionMessageRaisedEventArgs>, InteractionMessageRaisedEventArgs> ( h => h, h => messenger.Raised += h, h => messenger.Raised -= h, MessageReceived ); }
/// <summary> /// Initializes a new instance of the <see cref="TableDefinition" /> class. /// </summary> public TableDefinition() { FieldList = new List<TableFieldDefinition>(); var relationships = new ObservableCollection<TableRelationshipDefinition>(); Relationships = relationships; var weakListenerKeyDown = new WeakEventListener<TableDefinition, ObservableCollection<TableRelationshipDefinition>, NotifyCollectionChangedEventArgs>(this, relationships); relationships.CollectionChanged += weakListenerKeyDown.OnEvent; weakListenerKeyDown.OnEventAction += RelationshipsCollectionChanged; weakListenerKeyDown.OnDetachAction += Static; }
/// <summary> /// Initializes a new instance of the <see cref="ServiceTypeInfo"/> class. /// </summary> /// <param name="type">The type.</param> public ServiceTypeInfo(ServiceExposedTypeEdit type) { _nameExpression = () => type.Name; _guidExpression = () => type.Guid; var propertyChangedListener = new WeakEventListener<ServiceTypeInfo, ServiceExposedTypeEdit, PropertyChangedEventArgs>(this, type); type.PropertyChanged += propertyChangedListener.OnEvent; propertyChangedListener.OnEventAction += OnTypePropertyChanged; propertyChangedListener.OnDetachAction += Static; }
public void ShouldStoreEventHandler() { bool weakEventReceived = false; var listener = new WeakEventListener<PropertyChangedEventArgs>((sender, eventArgs) => weakEventReceived = true); // Check whether EventHandler was stored correctly. Assert.IsNotNull(listener.EventHandler); listener.EventHandler(null, null); Assert.IsTrue(weakEventReceived); weakEventReceived = false; }
private static void OnDataContextChanged(SearchListView view, object sender, DependencyPropertyChangedEventArgs args) { var dc = args.NewValue as SearchListViewModel; if (dc == null) return; var selectedChangedListener = new WeakEventListener<SearchListView, SearchListViewModel, SelectedChangedEventArgs>(view, dc); dc.SelectedChanged += selectedChangedListener.OnEvent; selectedChangedListener.OnEventAction = OnSelectedChanged; selectedChangedListener.OnDetachAction = OnDetachSelectedChanged; }
public void ShouldStoreEventHandler() { bool weakEventReceived = false; var listener = new WeakEventListener <PropertyChangedEventArgs>((sender, eventArgs) => weakEventReceived = true); // Check whether EventHandler was stored correctly. Assert.IsNotNull(listener.EventHandler); listener.EventHandler(null, null); Assert.IsTrue(weakEventReceived); weakEventReceived = false; }
/// <summary> /// Adds the event handlers. /// </summary> private void AddEventHandlers() { var propertyChangedListener = new WeakEventListener<BusinessObjectIsValidListener, BusinessBase, PropertyChangedEventArgs>(this, Model); Model.PropertyChanged += propertyChangedListener.OnEvent; propertyChangedListener.OnEventAction = OnModelPropertyChanged; propertyChangedListener.OnDetachAction = Static; var childChangedListener = new WeakEventListener<BusinessObjectIsValidListener, BusinessBase, ChildChangedEventArgs>(this, Model); Model.ChildChanged += childChangedListener.OnEvent; childChangedListener.OnEventAction = OnModelChildChanged; childChangedListener.OnDetachAction = Static; }
private static void OnValuePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { var obj = (IsNullOrEmptyStateTrigger)d; var val = e.NewValue; obj.IsActive = IsNullOrEmpty(val); if (val == null) return; // Try to listen for various notification events // Starting with INorifyCollectionChanged var valNotifyCollection = val as INotifyCollectionChanged; if (valNotifyCollection != null) { var weakEvent = new WeakEventListener<INotifyCollectionChanged, object, NotifyCollectionChangedEventArgs>(valNotifyCollection) { OnEventAction = (instance, source, args) => obj.IsActive = IsNullOrEmpty(instance), OnDetachAction = (instance, weakEventListener) => instance.CollectionChanged -= weakEventListener.OnEvent }; valNotifyCollection.CollectionChanged += weakEvent.OnEvent; return; } // Not INotifyCollectionChanged, try IObservableVector var valObservableVector = val as IObservableVector<object>; if (valObservableVector != null) { var weakEvent = new WeakEventListener<IObservableVector<object>, object, IVectorChangedEventArgs>(valObservableVector) { OnEventAction = (instance, source, args) => obj.IsActive = IsNullOrEmpty(instance), OnDetachAction = (instance, weakEventListener) => instance.VectorChanged -= weakEventListener.OnEvent }; valObservableVector.VectorChanged += weakEvent.OnEvent; return; } // Not INotifyCollectionChanged, try IObservableMap var valObservableMap = val as IObservableMap<object,object>; if (valObservableMap != null) { var weakEvent = new WeakEventListener<IObservableMap<object, object>, object, IMapChangedEventArgs<object>>(valObservableMap) { OnEventAction = (instance, source, args) => obj.IsActive = IsNullOrEmpty(instance), OnDetachAction = (instance, weakEventListener) => instance.MapChanged -= weakEventListener.OnEvent }; valObservableMap.MapChanged += weakEvent.OnEvent; } }
/// <summary> /// Initializes a new instance of the <see cref="AdaptiveTrigger"/> class. /// </summary> public AdaptiveTrigger() { var window = CoreApplication.GetCurrentView()?.CoreWindow; if (window != null) { var weakEvent = new WeakEventListener<AdaptiveTrigger, CoreWindow, WindowSizeChangedEventArgs>(this) { OnEventAction = (instance, s, e) => OnCoreWindowOnSizeChanged(s, e), OnDetachAction = (instance, weakEventListener) => window.SizeChanged -= weakEventListener.OnEvent }; window.SizeChanged += weakEvent.OnEvent; } }
public MasterDetailStateTrigger() { if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled) { var weakEvent = new WeakEventListener<MasterDetailStateTrigger, ApplicationView, object>(this) { OnEventAction = (instance, source, eventArgs) => MasterDetailStatetateTrigger_MasterDetailStateChanged(source, eventArgs), OnDetachAction = (instance, weakEventListener) => ApplicationView.GetForCurrentView().VisibleBoundsChanged -= weakEventListener.OnEvent }; ApplicationView.GetForCurrentView().VisibleBoundsChanged += weakEvent.OnEvent; } }
/// <summary> /// Initializes a new instance of the <see cref="OrientationStateTrigger"/> class. /// </summary> public OrientationStateTrigger() { if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled) { var weakEvent = new WeakEventListener<OrientationStateTrigger, DisplayInformation, object>(this) { OnEventAction = (instance, source, eventArgs) => OrientationStateTrigger_OrientationChanged(source, eventArgs), OnDetachAction = (instance, weakEventListener) => DisplayInformation.GetForCurrentView().OrientationChanged -= weakEventListener.OnEvent }; DisplayInformation.GetForCurrentView().OrientationChanged += weakEvent.OnEvent; } }
public DocumentationStepView() { InitializeComponent(); var contextMenu = new ContextMenu(); var contextMenuShowingListener = new WeakEventListener<DocumentationStepView, ContextMenu, ContextMenuEventArgs>(this, contextMenu); contextMenu.Showing += contextMenuShowingListener.OnEvent; contextMenuShowingListener.OnEventAction += ContextMenu_Showing; contextMenuShowingListener.OnDetachAction += Static; HTMLRichTextBox.ContextMenu = contextMenu; Loaded += DocumentationStepView_Loaded; Unloaded += OnUnloaded; }
/// <summary> /// Initializes a new instance of the <see cref="UserInteractionModeTrigger"/> class. /// </summary> public UserInteractionModeTrigger() { if (!Windows.ApplicationModel.DesignMode.DesignModeEnabled) { var weakEvent = new WeakEventListener<UserInteractionModeTrigger, object, WindowSizeChangedEventArgs>(this) { OnEventAction = (instance, source, eventArgs) => UserInteractionModeTrigger_SizeChanged(source, eventArgs), OnDetachAction = (instance, weakEventListener) => Window.Current.SizeChanged -= weakEventListener.OnEvent }; Window.Current.SizeChanged += weakEvent.OnEvent; UpdateTrigger(InteractionMode); } }
public StopPopupControl() { this.InitializeComponent(); MainGrid.DataContext = VM; VM.PropertyChanged += VM_PropertyChanged; RefreshMainGridWidth(); //ExpandButton.SetBinding(Button.CommandProperty, new Binding() { Source = this, Path = new PropertyPath("ExpandCommand") }); //CompressButton.SetBinding(Button.CommandProperty, new Binding() { Source = this, Path = new PropertyPath("CompressCommand") }); //CloseButton.SetBinding(Button.CommandProperty, new Binding() { Source = this, Path = new PropertyPath("CloseCommand") }); //RegisterPropertyChangedCallback(WidthProperty, WidthChanged); ShownArrivalsBinding = new CompositeCollectionBinding<RealTimeArrival, string>(ShownArrivals); WeakEventListener<StopPopupControl, object, NotifyCollectionChangedEventArgs> childrenListener = new WeakEventListener<StopPopupControl, object, NotifyCollectionChangedEventArgs>(this); childrenListener.OnEventAction = (t, s, e) => t.Children_CollectionChanged(s, e); VM.Children.CollectionChanged += childrenListener.OnEvent; }
public void AllowsGarbageCollection() { Dummy dummy = new Dummy(); bool weakEventReceived = false; var listener = new WeakEventListener<PropertyChangedEventArgs>((sender, eventArgs) => weakEventReceived = true); PropertyChangedEventManager.AddListener(dummy, listener, String.Empty); WeakReference weakReference = new WeakReference(listener); listener = null; GC.Collect(); Assert.IsFalse(weakReference.IsAlive); Assert.IsFalse(weakEventReceived); }
private void OnDataContextChanged(object sender, DependencyPropertyChangedEventArgs args) { var newDc = args.NewValue as IFieldViewModel; if (newDc == null) return; DetachDisposedListener(); _disposedListener = new WeakEventListener<DynamicItemsSelectorView, IFieldViewModel, EventArgs>(this, newDc) { OnEventAction = OnDataContextDisposed, OnDetachAction = OnDetachDataContextDisposed }; newDc.Disposed += _disposedListener.OnEvent; }
/// <summary> /// Initializes a new instance of the <see cref="AdaptiveTrigger"/> class. /// </summary> public AdaptiveTrigger() { this.RegisterPropertyChangedCallback(MinWindowHeightProperty, OnMinWindowHeightPropertyChanged); this.RegisterPropertyChangedCallback(MinWindowWidthProperty, OnMinWindowWidthPropertyChanged); var window = CoreApplication.GetCurrentView()?.CoreWindow; if (window != null) { var weakEvent = new WeakEventListener<AdaptiveTrigger, CoreWindow, WindowSizeChangedEventArgs>(this) { OnEventAction = (instance, s, e) => OnCoreWindowOnSizeChanged(s, e), OnDetachAction = (instance, weakEventListener) => window.SizeChanged -= weakEventListener.OnEvent }; window.SizeChanged += weakEvent.OnEvent; } }
/// <summary> /// Initializes the specified model. /// </summary> /// <param name="model">The model.</param> /// <param name="processEdit">The process edit.</param> /// <param name="fieldEdit">The field edit.</param> public void Init(ChecklistSettingsStepEdit model, ProcessEdit processEdit, FieldEdit fieldEdit) { StepModel = model; ProcessEdit = processEdit; FieldEdit = fieldEdit; FilterGuid = model.FilterGuid ?? Guid.Empty; FilterDefinition = model.FilterDefinition; var weakListener = new WeakEventListener<ChecklistFilterViewModel, ChecklistSettingsStepEdit, PropertyChangedEventArgs>(this, model); model.PropertyChanged += weakListener.OnEvent; weakListener.OnEventAction += OnReqStepPropertyChanged; weakListener.OnDetachAction += Static; LoadProcessInfo(model); }