private static void OnPasswordPropertyChanged(DependencyObject sender,
DependencyPropertyChangedEventArgs e)
{
var passwordBox = sender as PasswordBox;
if (passwordBox == null)
{
return;
}
WeakEventManager <PasswordBox, RoutedEventArgs>
.RemoveHandler(passwordBox, "PasswordChanged", PasswordChanged);
if (!GetUpdatingPassword(passwordBox))
{
passwordBox.Password = e.NewValue as string;
}
WeakEventManager <PasswordBox, RoutedEventArgs>
.AddHandler(passwordBox, "PasswordChanged", PasswordChanged);
}
static void Main(string[] args)
{
var manager = new MailManager();
var fax = new Fax();
//自定义弱事件使用
//EventManager.AddListener(manager, fax);
//.net4.5集成后使用
WeakEventManager <MailManager, NewMailEventArgs> .
AddHandler(manager, "NewMail", fax.FaxMsg);
manager.SimulateNewMail("1", "2", "3");
fax = null;
GC.Collect();
GC.WaitForPendingFinalizers();
GC.Collect();
manager.SimulateNewMail("1", "2", "3");
Console.Read();
}
private void AddSubscriptions(object dc)
{
ObservableSourceStatusEnum workStatus = ObservableSourceStatusEnum.Undetermined;
bool addedIt = false;
if (dc is INotifyPCGen pcGen)
{
WeakEventManager <INotifyPCGen, PcGenEventArgs>
.AddHandler(pcGen, "PropertyChangedWithGenVals", PCGenEvent_Handler);
workStatus = ObservableSourceStatusEnum.IsWatchingProp;
addedIt = true;
}
if (dc is INotifyPropertyChanged pc)
{
WeakEventManager <INotifyPropertyChanged, PropertyChangedEventArgs>
.AddHandler(pc, "PropertyChanged", OnPCEvent);
workStatus = ObservableSourceStatusEnum.IsWatchingProp;
addedIt = true;
}
if (dc is INotifyCollectionChanged cc)
{
WeakEventManager <INotifyCollectionChanged, CollectionChangeEventArgs>
.AddHandler(cc, "CollectionChanged", OnCCEvent);
workStatus = workStatus.SetWatchingColl();
addedIt = true;
}
if (!addedIt)
{
string msg = "Cannot create subscriptions. Object does not implement INotifyPropertyChanged, " +
"nor does it implement INotifyCollectionChanged.";
System.Diagnostics.Debug.WriteLine(msg);
//throw new ApplicationException(msg);
}
Status = workStatus;
}
protected virtual PathThumb CreateThumb(PlacementAlignment alignment, Cursor cursor, int index,
PathPoint pathpoint, Transform transform)
{
var designerThumb = new PathThumb(index, pathpoint)
{
Cursor = cursor
};
designerThumb.OperationMenu = BuildMenu(pathpoint);
designerThumb.InnerRenderTransform = ((Transform)transform.Inverse);
if (pathpoint.TargetPathPoint != null)
{
designerThumb.IsEllipse = true;
designerThumb.Foreground = Brushes.Blue;
var bnd = new Binding("TranslatedPoint")
{
Source = pathpoint.TargetPathPoint,
Mode = BindingMode.OneWay,
Converter = new RelativeToPointConverter(pathpoint)
};
designerThumb.SetBinding(PathThumb.RelativeToPointProperty, bnd);
}
AdornerPanel.SetPlacement(designerThumb, designerThumb.AdornerPlacement);
adornerPanel.Children.Add(designerThumb);
DragListener drag = new DragListener(designerThumb);
drag.Transform = transform;
WeakEventManager <DesignerThumb, MouseButtonEventArgs> .AddHandler(designerThumb,
"PreviewMouseLeftButtonDown", ResizeThumbOnMouseLeftButtonUp);
drag.MouseDown += drag_MouseDown;
drag.Started += drag_Started;
drag.Changed += drag_Changed;
drag.Completed += drag_Completed;
return(designerThumb);
}
internal WinRTSpellerInterop()
{
new FileIOPermission(PermissionState.None)
{
AllLocalFiles = FileIOPermissionAccess.PathDiscovery
}.Assert();
try
{
SpellCheckerFactory.Create(false);
}
catch (Exception ex) when(ex is InvalidCastException || ex is COMException)
{
this.Dispose();
throw new PlatformNotSupportedException(string.Empty, ex);
}
finally
{
CodeAccessPermission.RevertAssert();
}
this._spellCheckers = new Dictionary <CultureInfo, Tuple <WordsSegmenter, SpellChecker> >();
this._customDictionaryFiles = new Dictionary <string, List <string> >();
InputLanguageManager inputLanguageManager = InputLanguageManager.Current;
this._defaultCulture = (((inputLanguageManager != null) ? inputLanguageManager.CurrentInputLanguage : null) ?? Thread.CurrentThread.CurrentCulture);
this._culture = null;
try
{
this.EnsureWordBreakerAndSpellCheckerForCulture(this._defaultCulture, true);
}
catch (Exception ex2) when(ex2 is ArgumentException || ex2 is NotSupportedException || ex2 is PlatformNotSupportedException)
{
this._spellCheckers = null;
this.Dispose();
if (ex2 is PlatformNotSupportedException || ex2 is NotSupportedException)
{
throw;
}
throw new NotSupportedException(string.Empty, ex2);
}
this._dispatcher = new WeakReference <Dispatcher>(Dispatcher.CurrentDispatcher);
WeakEventManager <AppDomain, UnhandledExceptionEventArgs> .AddHandler(AppDomain.CurrentDomain, "UnhandledException", new EventHandler <UnhandledExceptionEventArgs>(this.ProcessUnhandledException));
}
/// <summary>
/// Class constructor
/// </summary>
public TreeListControllerViewModel()
{
_SlowStuffSemaphore = new SemaphoreSlim(1, 1);
_OneTaskScheduler = new OneTaskLimitedScheduler();
_CancelTokenSourc = new CancellationTokenSource();
FolderItemsView = FileListView.Factory.CreateFileListViewModel();
FolderTextPath = FolderControlsLib.Factory.CreateFolderComboBoxVM();
RecentFolders = FileSystemModels.Factory.CreateBookmarksViewModel();
TreeBrowser = FolderBrowser.FolderBrowserFactory.CreateBrowserViewModel(false);
// This is fired when the user selects a new folder bookmark from the drop down button
WeakEventManager <ICanNavigate, BrowsingEventArgs>
.AddHandler(RecentFolders, "BrowseEvent", FolderTextPath_BrowseEvent);
// This is fired when the text path in the combobox changes to another existing folder
WeakEventManager <ICanNavigate, BrowsingEventArgs>
.AddHandler(FolderTextPath, "BrowseEvent", FolderTextPath_BrowseEvent);
Filters = FilterControlsLib.Factory.CreateFilterComboBoxViewModel();
WeakEventManager <IFilterComboBoxViewModel, FilterChangedEventArgs>
.AddHandler(Filters, "OnFilterChanged", FileViewFilter_Changed);
// This is fired when the current folder in the listview changes to another existing folder
WeakEventManager <ICanNavigate, BrowsingEventArgs>
.AddHandler(FolderItemsView, "BrowseEvent", FolderTextPath_BrowseEvent);
// Event fires when the user requests to add a folder into the list of recently visited folders
WeakEventManager <IEditBookmarks, EditBookmarkEvent>
.AddHandler(FolderItemsView.BookmarkFolder, "RequestEditBookmarkedFolders", FolderItemsView_RequestEditBookmarkedFolders);
// This event is fired when a user opens a file
WeakEventManager <IFileOpenEventSource, FileOpenEventArgs>
.AddHandler(FolderItemsView, "OnFileOpen", FolderItemsView_OnFileOpen);
WeakEventManager <ICanNavigate, BrowsingEventArgs>
.AddHandler(TreeBrowser, "BrowseEvent", FolderTextPath_BrowseEvent);
// Event fires when the user requests to add a folder into the list of recently visited folders
WeakEventManager <IEditBookmarks, EditBookmarkEvent>
.AddHandler(TreeBrowser.BookmarkFolder, "RequestEditBookmarkedFolders", FolderItemsView_RequestEditBookmarkedFolders);
}
public override void OnApplyTemplate()
{
this.tab1 = this.GetTemplateChild(PARTIDTab1) as ContentPresenter;
WeakEventManager <ContentPresenter, MouseButtonEventArgs> .AddHandler(this.tab1, nameof(this.tab1.PreviewMouseDown), (s, e) =>
{
if (this.SelectedTabContent == null || this.SelectedTabContent == this.SecondTabContent)
{
this.SelectedTabContent = this.FirstTabContent;
}
});
this.tab2 = this.GetTemplateChild(PARTIDTab2) as ContentPresenter;
WeakEventManager <ContentPresenter, MouseButtonEventArgs> .AddHandler(this.tab2, nameof(this.tab2.PreviewMouseDown), (s, e) =>
{
if (this.SelectedTabContent == null || this.SelectedTabContent == this.FirstTabContent)
{
this.SelectedTabContent = this.SecondTabContent;
}
});
}
static void Main(string[] args)
{
var dealer = new CarDealer();
var daniel = new Consumer("Daniel");
WeakEventManager <CarDealer, CarInfoEventArgs> .AddHandler(dealer, "NewCarInfo", daniel.NewCarIsHere);
dealer.NewCar("Mercedes");
var sebastian = new Consumer("Sebastian");
WeakEventManager <CarDealer, CarInfoEventArgs> .AddHandler(dealer, "NewCarInfo", sebastian.NewCarIsHere);
dealer.NewCar("Ferrari");
WeakEventManager <CarDealer, CarInfoEventArgs> .RemoveHandler(dealer, "NewCarInfo", daniel.NewCarIsHere);
dealer.NewCar("Red Bull Racing");
}
private TelescopeSettingsProvider()
{
_SettingsFile = Path.Combine(UserSettingsFolder, CONFIG_SETTINGS_FILENAME);
if (_Settings == null)
{
LoadSettings();
}
if (_Watcher == null)
{
// Add file watcher
_Watcher = new FileSystemWatcher();
_Watcher.Path = UserSettingsFolder;
_Watcher.Filter = CONFIG_SETTINGS_FILENAME;
// _Watcher.Changed += _Config_Changed;
WeakEventManager <FileSystemWatcher, FileSystemEventArgs> .AddHandler(_Watcher, "Changed", _Config_Changed);
_Watcher.EnableRaisingEvents = true;
}
}
public static void Start1()
{
var dealer = new CarDealer();
var michael = new Consumer("Michael");
WeakEventManager <CarDealer, CarInfoEventArgs> .AddHandler(dealer, "NewCarInfo", michael.NewCarIsHere);
dealer.NewCar("Mercedes");
var sebastian = new Consumer("Sebastian");
WeakEventManager <CarDealer, CarInfoEventArgs> .AddHandler(dealer, "NewCarInfo", sebastian.NewCarIsHere);
dealer.NewCar("Ferrari");
WeakEventManager <CarDealer, CarInfoEventArgs> .RemoveHandler(dealer, "NewCarInfo", michael.NewCarIsHere);
dealer.NewCar("Red Bull Racing");
}
public AutoCorrectionResult TryApply(AutoCorrectionInput input)
{
bool success = false;
foreach (var wordRange in input.Context.GetWords())
{
string wordText = wordRange.TextOnly();
var url = TryCreateUrl(wordText);
if (url != null && !IsInHyperlinkScope(wordRange.Start) && !IsInHyperlinkScope(wordRange.End))
{
var hyperlink = new Hyperlink(wordRange.Start, wordRange.End);
hyperlink.NavigateUri = url;
WeakEventManager <Hyperlink, RequestNavigateEventArgs> .AddHandler(hyperlink, "RequestNavigate", OnHyperlinkRequestNavigate);
success = true;
}
}
return(new AutoCorrectionResult(success));
}
private static Func <bool> AddWeakEvent(Class1 c1, WeakReference <Class2> weak2)
{
if (weak2.TryGetTarget(out var c2))
{
WeakEventManager <Class1, EventArgs> .AddHandler(c1, "Event1", c2.OnEvent1);
return(() =>
{
if (weak2.TryGetTarget(out var c))
{
WeakEventManager <Class1, EventArgs> .RemoveHandler(c1, "Event1", c.OnEvent1);
return true;
}
return false;
});
}
return(() => false);
}
public SettingsView()
{
//http://stackoverflow.com/questions/19221634/opening-a-prism-module-on-new-window-on-a-registered-region
regionManager = ServiceLocator.Current.GetInstance(typeof(IRegionManager)) as IRegionManager;
this.SetValue(RegionManager.RegionManagerProperty, regionManager);
InitializeComponent();
ViewModel = ServiceLocator.Current.GetInstance(typeof(SettingsViewModel)) as SettingsViewModel;
WeakEventManager <SettingsViewModel, CloseableBindableBase.DialogEventArgs> .AddHandler(ViewModel, "ClosingRequest", ClosingRequest);
if (ViewModel.Categories.Count > 0)
{
ViewModel.SelectedCategory = ViewModel.Categories[0];
}
DataContext = ViewModel;
this.Closed += globalSettingsView_Closed;
}
public void ApplyCursorTo(FrameworkElement element)
{
_element = element;
var layer = AdornerLayer.GetAdornerLayer(element);
var hideCursor = (_cursorAdorner == null || _cursorAdorner.Visibility == Visibility.Hidden);
if (_cursorAdorner != null)
layer.Remove(_cursorAdorner);
_cursorAdorner = new ToolCursorAdorner(element, Render);
layer.Add(_cursorAdorner);
WeakEventManager<FrameworkElement, MouseEventArgs>.AddHandler(element, "MouseEnter", MouseEnter);
WeakEventManager<FrameworkElement, MouseEventArgs>.AddHandler(element, "MouseLeave", MouseLeave);
element.Cursor = Cursors.None;
if (hideCursor)
_cursorAdorner.Visibility = Visibility.Hidden;
}
public static void Main()
{
var dealer = new CarDealer2();
var kaka = new Consumer2("Kaka");
WeakEventManager <CarDealer2, CarInfoEventArgs2> .AddHandler(dealer, "NewCarInfo", kaka.NewCarIsHere);
// WeakCarInfoEventManager.AddListener(dealer, kaka);
dealer.NewCar("Audi Q5");
var john = new Consumer2("John");
WeakEventManager <CarDealer2, CarInfoEventArgs2> .AddHandler(dealer, "NewCarInfo", john.NewCarIsHere);
// WeakCarInfoEventManager.AddListener(dealer, john);
dealer.NewCar("Audi A6L");
WeakEventManager <CarDealer2, CarInfoEventArgs2> .RemoveHandler(dealer, "NewCarInfo", john.NewCarIsHere);
// WeakCarInfoEventManager.RemoveListener(dealer, john);
dealer.NewCar("Audi A8");
}
static void Main(string[] args)
{
CarDealer deAutos = new CarDealer("deAutos.com");
PotentialCarBuyer roberto = new PotentialCarBuyer("Roberto Planta");
PotentialCarBuyer ricardo = new PotentialCarBuyer("Ricky Fort");
PotentialCarBuyer jose = new PotentialCarBuyer("José López");
WeakEventManager <CarDealer, NewCarEventArgs> .AddHandler(deAutos, "NewCarEvent", roberto.NewCarEventListener);
deAutos.NewCar("Renault18");
WeakEventManager <CarDealer, NewCarEventArgs> .AddHandler(deAutos, "NewCarEvent", ricardo.NewCarEventListener);
deAutos.NewCar("Torino");
WeakEventManager <CarDealer, NewCarEventArgs> .AddHandler(deAutos, "NewCarEvent", jose.NewCarEventListener);
deAutos.NewCar("Toyota Celica");
WeakEventManager <CarDealer, NewCarEventArgs> .RemoveHandler(deAutos, "NewCarEvent", jose.NewCarEventListener);
deAutos.NewCar("Ford T");
}
private static void BindPassword(DependencyObject sender,
DependencyPropertyChangedEventArgs e)
{
var passwordBox = sender as PasswordBox;
if (passwordBox == null)
{
return;
}
if ((bool)e.OldValue)
{
WeakEventManager <PasswordBox, RoutedEventArgs>
.RemoveHandler(passwordBox, "PasswordChanged", PasswordChanged);
}
if ((bool)e.NewValue)
{
WeakEventManager <PasswordBox, RoutedEventArgs>
.AddHandler(passwordBox, "PasswordChanged", PasswordChanged);
}
}
public Events()
{
Student student = new Student("Aurel", 320);
EventForMe me = new EventForMe();
EventForBank bank = new EventForBank();
student.Notificator += me.Notify;
student.Notificator += bank.Notify;
student.Move(10);
student.Read("Goat with 3 kids");
student.MoneyData();
student.AddMoney(25);
student.MoneyData();
student.SpendMoney(145);
student.MoneyData();
student.SpendMoney(250);
student.MoneyData();
student.Notificator -= bank.Notify;
student.Notificator -= me.Notify;
WeakEventManager <Student, StudentEventArgs> .AddHandler(student, "Notificator", me.Notify);
WeakEventManager <Student, StudentEventArgs> .AddHandler(student, "Notificator", bank.Notify);
student.Move(12);
Console.WriteLine("------------------------------------------------------------------");
WeakEventManager <Student, StudentEventArgs> .RemoveHandler(student, "Notificator", bank.Notify);
student.Move(12);
}
/// <summary>
/// Initializes a new instance of the <see cref="ProjectViewModel" /> class.
/// </summary>
/// <param name="application">The application.</param>
/// <param name="platformProvider">The platform provider.</param>
/// <param name="eventAggregator">The event aggregator.</param>
/// <param name="buildTracker">The build tracker.</param>
/// <param name="buildFactory">The build factory.</param>
/// <param name="settingsId">The settings identifier.</param>
/// <param name="projectId">The project identifier.</param>
/// <param name="projectName">The project name.</param>
public ProjectViewModel(
IApp application,
IPlatformProvider platformProvider,
IEventAggregator eventAggregator,
IBuildTracker buildTracker,
IBuildViewModelFactory buildFactory,
Guid settingsId,
string projectId,
string projectName)
: base(platformProvider)
{
Ensure.That(application).IsNotNull();
Ensure.That(eventAggregator).IsNotNull();
Ensure.That(buildTracker).IsNotNull();
Ensure.That(buildFactory).IsNotNull();
Ensure.That(settingsId).IsNotEmpty();
Ensure.That(projectId).IsNotNullOrWhiteSpace();
_application = application;
_eventAggregator = eventAggregator;
_buildFactory = buildFactory;
_settingsId = settingsId;
Id = projectId;
_name = projectName;
_isBusy = true;
_isErrored = false;
DisplayName = Properties.Resources.Project_View;
WeakEventManager <IBuildTracker, BuildTrackerProjectErrorEventArgs> .AddHandler(buildTracker, nameof(buildTracker.ProjectError), BuildTrackerProjectError);
WeakEventManager <IBuildTracker, BuildTrackerProjectProgressEventArgs> .AddHandler(buildTracker, nameof(buildTracker.ProjectProgressChanged), BuildTrackerProjectProgressChanged);
_builds = new BindableCollection <IBuildViewModel>();
_orderedBuilds = new CollectionViewSource
{
Source = _builds
};
OrderedBuilds = _orderedBuilds.View;
}
private static void TextBox_Changed(
DependencyObject d, DependencyPropertyChangedEventArgs e)
{
// When this property gets set, attach the correct event handler,
// so that we can listen to text changes.
if (d is TextBox textBox)
{
WeakEventManager <TextBox, TextChangedEventArgs> .AddHandler(
textBox,
nameof(TextBox.TextChanged),
TextBox_TextChanged);
UpdateHasTextForTextBox(textBox);
textBox.TraceVerbose("TextBoxHelper - Attached TextChanged handler.");
}
else if (d is RichTextBox richTextBox)
{
WeakEventManager <RichTextBox, TextChangedEventArgs> .AddHandler(
richTextBox,
nameof(RichTextBox.TextChanged),
RichTextBox_TextChanged);
UpdateHasTextForRichTextBox(richTextBox);
richTextBox.TraceVerbose("TextBoxHelper - Attached TextChanged handler.");
}
else if (d is PasswordBox passwordBox)
{
WeakEventManager <PasswordBox, RoutedEventArgs> .AddHandler(
passwordBox,
nameof(PasswordBox.PasswordChanged),
PasswordBox_PasswordChanged);
UpdateHasTextForPasswordBox(passwordBox);
passwordBox.TraceVerbose("TextBoxHelper - Attached PasswordChanged handler.");
}
// Clear the value to not create memory leaks.
// If this isn't called, the dep.prop. stores a reference to itself,
// forever and ever.
d.ClearValue(TextBoxProperty);
}
private void AssignToModel(IChatWindowModel chatWindow)
{
PropertyChangedEventManager.AddHandler(
chatWindow,
(_, __) => Content = chatWindow.Content,
nameof(chatWindow.Content));
WeakEventManager <IChatWindowModel, EventArgs> .AddHandler(
chatWindow,
nameof(chatWindow.Closing),
(_, __) => Close()
);
WeakEventManager <IChatWindowModel, EventArgs> .AddHandler(
chatWindow,
nameof(chatWindow.HideRequested),
(_, __) => Appearance.HideCommand.Execute()
);
GoNextRequested += (_, __) => chatWindow.Flush();
}
private void OnItemsSourceChanged(IList oldValue, IList newValue)
{
#if DEBUG_SlimItemsControl
Debug.WriteLine($"{this.Name}({this.GetHashCode()})....OnItemsSourceChanged....newValue={newValue}");
#endif
ReloadAllItems();
if (oldValue is INotifyCollectionChanged oldItemsSource)
{
WeakEventManager <INotifyCollectionChanged, NotifyCollectionChangedEventArgs>
.AddHandler(oldItemsSource, "CollectionChanged", ItemsSource_CollectionChanged);
}
if (newValue is INotifyCollectionChanged newItemsSource)
{
WeakEventManager <INotifyCollectionChanged, NotifyCollectionChangedEventArgs>
.AddHandler(newItemsSource, "CollectionChanged", ItemsSource_CollectionChanged);
}
}
protected DesignerThumb CreateThumb(PlacementAlignment alignment, Cursor cursor, int index)
{
DesignerThumb designerThumb = new MultiPointThumb {
Index = index, Alignment = alignment, Cursor = cursor, IsPrimarySelection = true
};
AdornerPlacement ap = Place(designerThumb, alignment, index);
(designerThumb as MultiPointThumb).AdornerPlacement = ap;
AdornerPanel.SetPlacement(designerThumb, ap);
adornerPanel.Children.Add(designerThumb);
DragListener drag = new DragListener(designerThumb);
WeakEventManager <DesignerThumb, MouseButtonEventArgs> .AddHandler(designerThumb, "PreviewMouseLeftButtonDown", ResizeThumbOnMouseLeftButtonUp);
drag.Started += drag_Started;
drag.Changed += drag_Changed;
drag.Completed += drag_Completed;
return(designerThumb);
}
private static void SelectionChanged(DependencyObject obj, DependencyPropertyChangedEventArgs e)
{
if (!(obj is TreeListView))
{
return;
}
var view = obj as TreeListView;
//view.SelectedItemChanged -= view_SelectedItemChanged;
//view.SelectedItemChanged += view_SelectedItemChanged;
WeakEventManager <TreeListView, RoutedPropertyChangedEventArgs <object> > .AddHandler(view, "SelectedItemChanged", view_SelectedItemChanged);
//if (!behaviors.ContainsKey(obj))
// behaviors.Add(obj, new TreeViewSelectedItemBehavior(obj as TreeListView));
//TreeViewSelectedItemBehavior view = behaviors[obj];
//view.ChangeSelectedItem(e.NewValue);
}
private static void coordinateChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
GeoTagEditorView view = (GeoTagEditorView)d;
if (e.OldValue != null)
{
GeoTagCoordinatePair coord = (GeoTagCoordinatePair)e.OldValue;
WeakEventManager <GeoTagCoordinatePair, EventArgs> .RemoveHandler(coord, "GeoTagChanged", view.coordinateChanged);
}
if (e.NewValue != null)
{
GeoTagCoordinatePair coord = (GeoTagCoordinatePair)e.NewValue;
view.showValues(true);
WeakEventManager <GeoTagCoordinatePair, EventArgs> .AddHandler(coord, "GeoTagChanged", view.coordinateChanged);
view.IsToolTipLocationSet = false;
}
}
public void AddDocumentView(DocumentViewModel vm, bool setActive)
{
if (vm == null)
{
throw new ArgumentNullException(nameof(vm));
}
UIDispatcher.Execute(() =>
{
WeakEventManager <DocumentViewModel, EventArgs>
.AddHandler(vm, "Closed", TabVm_Closed);
_viewModels.Add(vm.UniqueId, vm);
DocumentViews.Add(vm.View as IDocumentView);
if (setActive)
{
SetActiveDocumentView(vm.View as IDocumentView);
}
OnCountChanged();
});
}
protected override void OnCollectionChanged(NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Add)
{
foreach (GameController gameController in e.NewItems)
{
// First remove the event because OnCollection changed is called twice when deserialising.
WeakEventManager <GameController, PropertyChangedEventArgs> .RemoveHandler(gameController, "PropertyChanged", GameController_PropertyChanged);
WeakEventManager <GameController, PropertyChangedEventArgs> .AddHandler(gameController, "PropertyChanged", GameController_PropertyChanged);
}
}
else if (e.Action == NotifyCollectionChangedAction.Remove)
{
foreach (GameController gameController in e.OldItems)
{
WeakEventManager <GameController, PropertyChangedEventArgs> .RemoveHandler(gameController, "PropertyChanged", GameController_PropertyChanged);
}
}
base.OnCollectionChanged(e);
}
private static void OnFocusTargetChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var source = (UIElement)d;
if (e.NewValue == null)
{
if (e.OldValue == null)
{
return;
}
WeakEventManager <UIElement, KeyboardFocusChangedEventArgs> .RemoveHandler(source, "GotKeyboardFocus", OnGotKeyboardFocus);
}
else
{
if (e.OldValue != null)
{
return;
}
WeakEventManager <UIElement, KeyboardFocusChangedEventArgs> .AddHandler(source, "GotKeyboardFocus", OnGotKeyboardFocus);
}
}
/// <summary>
/// Instantiates a CodeStructureAdorner manager when a textView is created.
/// </summary>
/// <param name="textView">The <see cref="IWpfTextView"/> upon which the adornment should be placed.</param>
public void TextViewCreated(IWpfTextView textView)
{
SteroidsVsPackage.EnsurePackageLoadedAsync().ContinueWith(
t =>
{
var bootstrapper = new CodeAdornmentsBootstrapper(textView);
if (_cleanupMap.ContainsKey(textView))
{
return;
}
_cleanupMap.Add(textView, bootstrapper);
var codeStructure = bootstrapper.GetService(typeof(CodeStructureAdorner)) as CodeStructureAdorner;
var diagnosticHints = bootstrapper.GetService(typeof(DiagnosticInfoAdorner)) as DiagnosticInfoAdorner;
WeakEventManager <ITextView, EventArgs> .AddHandler(textView, nameof(ITextView.Closed), OnClosed);
},
CancellationToken.None,
TaskContinuationOptions.ExecuteSynchronously,
TaskScheduler.Default);
}
public void RegisterBoardField(BoardField field)
{
if (field == _field)
{
return;
}
if (_field != null)
{
WeakEventManager <BoardField, PropertyChangedEventArgs> .RemoveHandler(
_field, nameof(_field.PropertyChanged), Field_PropertyChanged);
}
_field = field;
if (_field != null)
{
WeakEventManager <BoardField, PropertyChangedEventArgs> .AddHandler(
_field, nameof(_field.PropertyChanged), Field_PropertyChanged);
OnPropertyChanged(nameof(Field));
Field_PropertyChanged(_field, new PropertyChangedEventArgs(""));
}
}
public void RemoveHandlerShouldRemoveAddedHandler()
{
var target = new WeakEventManager<EventHandler, EventArgs>();
EventHandler handler = DefaultAction.None;
target.AddHandler( handler );
Assert.True( target.RemoveHandler( handler ) );
}
public void RaiseEventShouldInvokeAddedHandler()
{ var raised = false;
EventHandler handler = ( s, e ) => raised = true;
var target = new WeakEventManager<EventHandler, EventArgs>();
target.AddHandler( handler );
target.RaiseEvent( this, EventArgs.Empty );
Assert.True( raised );
}
public void RemoveHandlerShouldNotRemoveUnaddedHandler()
{
var target = new WeakEventManager<EventHandler, EventArgs>();
EventHandler handler1 = ( s, e ) =>
{
};
EventHandler handler2 = ( s, e ) =>
{
};
target.AddHandler( handler1 );
Assert.False( target.RemoveHandler( handler2 ) );
}
