private void RemoveViewFor(ReactiveViewModel viewModel)
{
var view = LookupView(viewModel);
_regionTarget.Items.Remove(view);
_viewContainer.Remove(viewModel);
}
protected internal override void AddView(INavigableRegion region, ReactiveViewModel viewModel)
{
var items = RegionTarget.ItemsSource as IList ?? RegionTarget.Items as IList;
if (items != null)
{
var sortableItem = viewModel as ISortable;
if (sortableItem != null)
{
var insertAtIndex = items.Count -
items
.OfType <FrameworkElement>()
.Select(x => x.DataContext)
.Cast <ISortable>()
.OrderBy(x => x.SortHint)
.SkipWhile(x => x.SortHint < sortableItem.SortHint)
.Count();
items.Insert(insertAtIndex, sortableItem);
}
else
{
items.Add(viewModel);
}
}
}
protected internal override void ActivateView(INavigableRegion region, ReactiveViewModel viewModel)
{
object view;
if (_cachedViews.TryGetValue(viewModel, out view))
{
RegionTarget.Content = view;
}
}
public void Run()
{
var target = new ReactiveViewModel();
var notificationOccured = false;
target.WhenAnyValue(m => m.Property).Subscribe(x => notificationOccured = true);
Assert.True(notificationOccured);
}
public bool Contains(ReactiveViewModel viewModel)
{
if (viewModel == null)
{
throw new ArgumentNullException("viewModel", "viewModel is null.");
}
return(_ownedViewModels.Keys.Contains(viewModel));
}
protected internal override void RemoveView(INavigableRegion region, ReactiveViewModel viewModel)
{
var items = RegionTarget.ItemsSource as IList ?? RegionTarget.Items as IList;
if (items.Contains(viewModel))
{
items.Remove(viewModel);
}
}
private async Task CloseExistingTarget(IRegion region, ReactiveViewModel navigationTarget, INavigationParameters parameters)
{
await Observable.Start(() => navigationTarget.Close(parameters), RxApp.TaskpoolScheduler).ToTask().ConfigureAwait(false);
await Observable.Start(() =>
{
region.Deactivate(navigationTarget);
region.Remove(navigationTarget);
}, RxApp.MainThreadScheduler).ToTask().ConfigureAwait(false);
}
public void SubscribesStream(User user)
{
var sut = new ReactiveViewModel <User, string>(user.Id);
sut.MonitorEvents();
Connect(user.Id).Emit(user);
sut.Model.Should().BeSameAs(user);
sut.ShouldRaisePropertyChangeFor(x => x.Model);
}
public void Add_ShouldPushAddedInstanceToAddedObservable()
{
var sut = Fixture.Create <Region>();
ReactiveViewModel addedVm = null;
var obs = sut.Added.Subscribe(x => addedVm = x);
var vm = sut.Add <ReactiveViewModel>();
addedVm.Should().Be(vm);
}
private async Task RequestNavigateAsyncInternal(IRegion region, ReactiveViewModel navigationTarget, INavigationParameters parameters)
{
var canNavigateTo = await Observable.Start(() => navigationTarget.CanNavigateTo(parameters), RxApp.MainThreadScheduler).ToTask().ConfigureAwait(false);
if (canNavigateTo)
{
await NavigateToExistingTarget(region, navigationTarget, parameters).ConfigureAwait(false);
}
await Task.FromResult(false);
}
protected internal override void ActivateView(INavigableRegion region, ReactiveViewModel viewModel)
{
try
{
_suppressSelectionChanged = true;
RegionTarget.SelectedItem = viewModel;
}
finally
{
_suppressSelectionChanged = false;
}
}
public object CreateViewFor(ReactiveViewModel viewModel)
{
var key = viewModel.GetType();
Func <ReactiveViewModel, object> createView;
if (_catalog.TryGetValue(key, out createView))
{
return(createView(viewModel));
}
throw new NotSupportedException();
}
public void ModelSetterRaisesEventWithModelChangedEventArgs(User user)
{
var sut = new ReactiveViewModel <User, string>(user.Id);
sut.MonitorEvents();
Connect(user.Id).Emit(user);
sut.ShouldRaisePropertyChangeFor(x => x.Model)
.WithArgs <PropertyChangedEventArgs>(args => ReferenceEquals(
args, ReactiveViewModel.ModelChangedEventArgs));
}
public async Task RequestClose(ReactiveViewModel navigationTarget, INavigationParameters parameters)
{
if (navigationTarget == null)
{
throw new ArgumentNullException("navigationTarget", "navigationTarget is null.");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters", "parameters is null.");
}
await Router.RequestCloseAsync(Region, navigationTarget, parameters).ConfigureAwait(false);
}
public void Activate_ShouldPushActivatedInstanceToActivatedObservable()
{
var sut = Fixture.Create <Region>();
ReactiveViewModel activatedVm = null;
var obs = sut.Activated.Subscribe(x => activatedVm = x);
var vm = sut.Add <ReactiveViewModel>(); // must add, before we can activate it
sut.Activate(vm);
activatedVm.Should().Be(vm);
}
public void Deactivate(ReactiveViewModel viewModel)
{
if (viewModel == null)
{
throw new ArgumentNullException("viewModel", "viewModel is null.");
}
if (!Contains(viewModel))
{
throw new ArgumentException("viewModel does not belong to region");
}
_deactivated.OnNext(viewModel);
}
public Task RequestClose(ReactiveViewModel navigationTarget, INavigationParameters parameters)
{
if (navigationTarget == null)
{
throw new ArgumentNullException("navigationTarget", "navigationTarget is null.");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters", "parameters is null.");
}
return(NavigableRegion.RequestClose(navigationTarget, parameters));
}
protected internal override void RemoveView(INavigableRegion region, ReactiveViewModel viewModel)
{
RegionTarget.Content = null;
object view;
if (_cachedViews.TryRemove(viewModel, out view))
{
var disposable = view as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
public void Add_WhenRegionAlreadyContainsAnItem_ShouldRemoveContainedItem()
{
var sut = Fixture.Create <SingleItemRegion>();
ReactiveViewModel removedVm = null;
using (var obs = sut.Removed.Subscribe(x => removedVm = x))
{
var vm = sut.Add <ReactiveViewModel>();
sut.Add <ReactiveViewModel>();
removedVm.Should().Be(vm);
}
}
public void Remove_ShouldPushRemovedInstanceToRemovedObservable()
{
var sut = Fixture.Create <Region>();
ReactiveViewModel removedVm = null;
sut.Removed.Subscribe(x => removedVm = x);
var vm = sut.Add <ReactiveViewModel>(); // must add, before we can remove it
sut.Remove(vm);
removedVm.Should().Be(vm);
}
private void ActivateViewFor(ReactiveViewModel viewModel)
{
var view = LookupView(viewModel);
try
{
_suppressSelectionChanged = true;
_regionTarget.SelectedItem = view;
}
finally
{
_suppressSelectionChanged = false;
}
}
public TabViewModel(INavigate router, ReactiveViewModel childViewModel)
{
if (router == null)
{
throw new ArgumentNullException("router", "router is null.");
}
if (childViewModel == null)
{
throw new ArgumentNullException("childViewModel", "childViewModel is null.");
}
_router = router;
_childViewModel = childViewModel;
Close = ReactiveCommand.CreateFromTask(_ => Router.RequestClose(ChildViewModel, NavigationParameters.UserNavigation));
}
public void Remove(ReactiveViewModel viewModel)
{
if (viewModel == null)
{
throw new ArgumentNullException("viewModel", "viewModel is null.");
}
if (!Contains(viewModel))
{
throw new ArgumentException("viewModel does not belong to region");
}
IDisposable scopedTarget;
if (_ownedViewModels.TryRemove(viewModel, out scopedTarget))
{
scopedTarget.Dispose();
_removed.OnNext(viewModel);
}
}
private void AddViewFor(INavigableRegion region, ReactiveViewModel viewModel)
{
var view = _viewFactory.CreateViewFor(viewModel);
var tabViewModel = new TabViewModel(region, viewModel);
var tabView = new TabView()
{
DataContext = tabViewModel
};
var tab = new TabItem
{
Header = tabView,
Content = view
};
_viewContainer.Add(viewModel, tab);
_regionTarget.Items.Add(tab);
}
public Task RequestNavigateAsync(IRegion region, ReactiveViewModel navigationTarget, INavigationParameters parameters)
{
if (region == null)
{
throw new ArgumentNullException("region", "region is null.");
}
if (navigationTarget == null)
{
throw new ArgumentNullException("navigationTarget", "navigationTarget is null.");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters", "parameters is null.");
}
if (!region.Contains(navigationTarget))
{
throw new ArgumentException("navigationTarget does not belong to region");
}
return(RequestNavigateAsyncInternal(region, navigationTarget, parameters));
}
public object CreateViewFor(ReactiveViewModel viewModel)
{
if (viewModel == null)
{
throw new ArgumentNullException("viewModel", "viewModel is null.");
}
var factory = _viewFactories[viewModel.GetType()];
var view = factory();
view.DataContext = viewModel;
// if RxUI bindings are used, also set ViewModel property
var rxView = view as IViewFor;
if (rxView != null)
{
rxView.ViewModel = viewModel;
}
return(view);
}
internal protected abstract void InitializeView(INavigableRegion region, ReactiveViewModel viewModel);
internal protected abstract void DeactivateView(INavigableRegion region, ReactiveViewModel viewModel);
protected internal override void InitializeView(INavigableRegion region, ReactiveViewModel viewModel)
{
}
protected internal override void DeactivateView(INavigableRegion region, ReactiveViewModel viewModel)
{
}
