private void SetParent(object source, object value)
{
if (source == null || ReferenceEquals(value, _parent.Target))
return;
_parent = ToolkitExtensions.GetWeakReferenceOrDefault(value, Empty.WeakReference, false);
Raise(source, EventArgs.Empty);
}
public virtual IViewModel TryTakeViewModelFromCache(INavigationContext context, object view)
{
view = ToolkitExtensions.GetUnderlyingView <object>(view);
var type = view.GetType();
List <IViewModel> list;
if (!_cachedViewModels.TryGetValue(type, out list) || list == null || list.Count == 0)
{
if (Tracer.TraceInformation)
{
Tracer.Info("Navigation cache - the view model for the view {0} is not found in the cache, navigation mode: {1}", type, context.NavigationMode);
}
return(null);
}
IViewModel vm = list[0];
list.RemoveAt(0);
if (list.Count == 0)
{
_cachedViewModels.Remove(type);
}
if (Tracer.TraceInformation)
{
Tracer.Info("Navigation cache - the view model {0} for the view {1} was taken from the cache, navigation mode: {2}",
vm.GetType(), type, context.NavigationMode);
}
return(vm);
}
public virtual void MediatorShouldCallOnNavigatingFromMethodOnClose()
{
bool result = false;
bool isInvoked = false;
var view = new DialogViewMock();
var vm = GetViewModel <NavigableViewModelMock>();
ViewManager.GetViewDelegate = (model, s) => view;
WindowViewMediatorBase <TView> windowMediator = Create(vm);
vm.OnNavigatingFromDelegate = o =>
{
o.ShouldNotBeNull();
isInvoked = true;
return(ToolkitExtensions.FromResult(result));
};
windowMediator.ShowAsync(null, DataContext.Empty);
windowMediator.CloseAsync(null).Result.ShouldBeFalse();
isInvoked.ShouldBeTrue();
isInvoked = false;
result = true;
windowMediator.CloseAsync(null).Result.ShouldBeTrue();
isInvoked.ShouldBeTrue();
}
public void Unsubscribe(bool dispose, bool oneTime)
{
if (_subscriber == null)
{
return;
}
if (dispose && oneTime && GetReferenceValue() is ICommand)
{
var penultimateValue = GetPenultimateValue();
if (!penultimateValue.IsNullOrUnsetValue())
{
LastContext = LastContext == null ? new DataContext() : new DataContext(LastContext);
LastContext.Remove(BindingConstants.Binding);
_source = ToolkitExtensions.GetWeakReference(penultimateValue);
return;
}
}
LastContext = null;
//it's normal here.
lock (this)
{
UnsubscribeEventHandler();
UnsubscribeCommand();
_valueReference = null;
}
if (dispose)
{
_canExecuteHandler = null;
}
}
private void SetValue(object newValue)
{
if (newValue == null)
{
UnsubscribeCommand();
_valueReference = null;
return;
}
var command = newValue as ICommand;
if (command == null)
{
if (!(newValue is BindingActionValue))
{
throw BindingExceptionManager.InvalidEventSourceValue(_currentValue.Member, newValue);
}
_valueReference = newValue;
}
else
{
var reference = _valueReference as WeakReference;
if (reference != null && ReferenceEquals(reference.Target, command))
{
return;
}
UnsubscribeCommand();
_valueReference = ToolkitExtensions.GetWeakReferenceOrDefault(command, null, true);
if (_toggleEnabledState && InitializeCanExecuteDelegate(command))
{
CommandOnCanExecuteChanged(command);
command.CanExecuteChanged += _canExecuteHandler;
}
}
}
protected override IBindingPathMembers UpdateInternal(IBindingPathMembers oldPath, bool hasSubscribers)
{
object source = GetActualSource();
if (source == null || source.IsUnsetValue())
{
return(UnsetBindingPathMembers.Instance);
}
var srcRef = OriginalSource as WeakReference;
if (oldPath != null && srcRef != null)
{
var members = oldPath as SingleBindingPathMembers;
if (members != null)
{
if (hasSubscribers)
{
_weakEventListener = TryObserveMember(source, members.LastMember, this, Path.Path);
}
return(members);
}
}
IBindingMemberInfo lastMember = BindingServiceProvider
.MemberProvider
.GetBindingMember(source.GetType(), Path.Path, _ignoreAttachedMembers, true);
if (hasSubscribers || srcRef == null)
{
_weakEventListener = TryObserveMember(source, lastMember, this, Path.Path);
}
return(new SingleBindingPathMembers(srcRef ?? ToolkitExtensions.GetWeakReference(source), Path, lastMember));
}
public BindingActionValue([NotNull] object memberSource, [NotNull] IBindingMemberInfo member)
{
Should.NotBeNull(memberSource, nameof(memberSource));
Should.NotBeNull(member, nameof(member));
_memberSource = ToolkitExtensions.GetWeakReference(memberSource);
_member = member;
}
public void ProviderShouldTrackPropertyChanges()
{
IEntityStateManager manager = GetStateManager();
var stateModel = GetModel();
var snapshot = manager.CreateSnapshot(stateModel);
snapshot.HasChanges(stateModel, ToolkitExtensions.GetMemberName <EntityStateModel>(() => model => model.Guid)).ShouldBeFalse();
snapshot.HasChanges(stateModel, ToolkitExtensions.GetMemberName <EntityStateModel>(() => model => model.String)).ShouldBeFalse();
snapshot.HasChanges(stateModel, ToolkitExtensions.GetMemberName <EntityStateModel>(() => model => model.Int)).ShouldBeFalse();
stateModel.Int = int.MaxValue;
stateModel.String = null;
stateModel.Guid = Guid.Empty;
snapshot.HasChanges(stateModel, ToolkitExtensions.GetMemberName <EntityStateModel>(() => model => model.Guid)).ShouldBeTrue();
snapshot.HasChanges(stateModel, ToolkitExtensions.GetMemberName <EntityStateModel>(() => model => model.String)).ShouldBeTrue();
snapshot.HasChanges(stateModel, ToolkitExtensions.GetMemberName <EntityStateModel>(() => model => model.Int)).ShouldBeTrue();
stateModel.Int = IntValue;
stateModel.String = StringValue;
stateModel.Guid = GuidValue;
snapshot.HasChanges(stateModel, ToolkitExtensions.GetMemberName <EntityStateModel>(() => model => model.Guid)).ShouldBeFalse();
snapshot.HasChanges(stateModel, ToolkitExtensions.GetMemberName <EntityStateModel>(() => model => model.String)).ShouldBeFalse();
snapshot.HasChanges(stateModel, ToolkitExtensions.GetMemberName <EntityStateModel>(() => model => model.Int)).ShouldBeFalse();
}
public void ProviderShouldNotCallOnNavigatingFromMethodNotCancelable()
{
bool isCancelInvoked = false;
bool isNavigatedInvoked = false;
const NavigationMode mode = NavigationMode.Refresh;
ViewPageMappingProvider.FindMappingForView = (type, b) => PageMapping;
NavigationProvider.CurrentViewModel.ShouldBeNull();
var viewModel = GetViewModel <NavigableViewModelMock>();
NavigationService.OnNavigated(new NavigationEventArgsMock(new ViewMock {
DataContext = viewModel
}, NavigationMode.New));
NavigationDispatcher.OnNavigatingFromAsync = context =>
{
isCancelInvoked = true;
context.NavigationProvider.ShouldEqual(NavigationProvider);
context.NavigationMode.ShouldEqual(mode);
return(ToolkitExtensions.FromResult(false));
};
NavigationDispatcher.OnNavigated = context => isNavigatedInvoked = true;
var cancelArgs = new NavigatingCancelEventArgsMock(mode, false)
{
Cancel = false
};
NavigationService.OnNavigating(cancelArgs);
isCancelInvoked.ShouldBeFalse();
isNavigatedInvoked.ShouldBeFalse();
}
public void ProviderShouldCallCloseAsyncMethodOnBackNavigation()
{
bool isCancelInvoked = false;
bool isNavigatedInvoked = false;
const NavigationMode mode = NavigationMode.Back;
ViewPageMappingProvider.FindMappingForView = (type, b) => PageMapping;
NavigationProvider.CurrentViewModel.ShouldBeNull();
var viewModel = GetViewModel <NavigableViewModelMock>();
NavigationService.OnNavigated(new NavigationEventArgsMock(new ViewMock {
DataContext = viewModel
}, NavigationMode.New));
viewModel.CloseDelegate = obj =>
{
isCancelInvoked = true;
var context = (INavigationContext)obj;
context.NavigationProvider.ShouldEqual(NavigationProvider);
context.NavigationMode.ShouldEqual(mode);
return(ToolkitExtensions.FromResult(false));
};
viewModel.OnNavigatedFromDelegate = context => isNavigatedInvoked = true;
var cancelArgs = new NavigatingCancelEventArgsMock(mode, true)
{
Cancel = false
};
NavigationService.OnNavigating(cancelArgs);
cancelArgs.Cancel.ShouldBeTrue();
isCancelInvoked.ShouldBeTrue();
isNavigatedInvoked.ShouldBeFalse();
}
public static TTask WithBusyIndicator <TTask>([NotNull] this TTask task, [NotNull] IViewModel viewModel,
object message = null, bool?handleException = null)
where TTask : Task
{
Should.NotBeNull(task, nameof(task));
Should.NotBeNull(viewModel, nameof(viewModel));
if (handleException == null)
{
handleException = ApplicationSettings.HandleTaskExceptionBusyIndicator;
}
if (task.IsCompleted)
{
if (handleException.Value)
{
ToolkitExtensions.TryHandleTaskException(task, viewModel, viewModel.GetIocContainer(true));
}
return(task);
}
var token = viewModel.BeginBusy(message);
task.TryExecuteSynchronously(t =>
{
token.Dispose();
if (handleException.Value)
{
ToolkitExtensions.TryHandleTaskException(t, viewModel, viewModel.GetIocContainer(true));
}
});
return(task);
}
public bool CanClose(IDataContext dataContext)
{
Should.NotBeNull(dataContext, nameof(dataContext));
var viewModel = dataContext.GetData(NavigationConstants.ViewModel);
if (viewModel == null)
{
return(false);
}
var content = CurrentContent;
var canClose = content != null && ToolkitExtensions.GetDataContext(content) == viewModel && _frame.CanGoBack;
if (canClose)
{
return(true);
}
var viewModelId = viewModel.GetViewModelId();
var backStack = _frame.BackStack;
for (int index = 0; index < backStack.Count; index++)
{
if (GetViewModelIdFromParameter(backStack[index].Parameter) == viewModelId)
{
return(true);
}
}
return(false);
}
private static void InitializeViewInternal(IViewModel viewModel, object view, IDataContext context)
{
if (view == null)
{
return;
}
if (viewModel != null)
{
viewModel.Settings.Metadata.AddOrUpdate(ViewModelConstants.View, view);
viewModel.Subscribe(view);
if (context.GetData(InitializationConstants.CanDisposeView))
{
ServiceProvider.AttachedValueProvider.SetValue(view, ViewManagerCreatorPath, null);
}
}
if (viewModel != null || ApplicationSettings.ViewManagerClearDataContext)
{
ToolkitExtensions.SetDataContext(view, viewModel);
}
ReflectionExtensions.GetViewModelPropertySetter(view.GetType())?.Invoke(view, viewModel);
if (viewModel == null)
{
(view as ICleanableView)?.Cleanup(context);
}
else
{
(view as IInitializableView)?.Initialize(viewModel, context);
}
}
public Task InitializeViewAsync(IViewModel viewModel, object view, IDataContext context = null)
{
var tcs = new TaskCompletionSource <object>();
ThreadManager.InvokeOnUiThreadAsync(() =>
{
if (context == null)
{
context = DataContext.Empty;
}
view = ToolkitExtensions.GetUnderlyingView <object>(view);
var oldView = viewModel.GetCurrentView <object>(false);
if (ReferenceEquals(oldView, view))
{
tcs.SetResult(null);
return;
}
if (oldView != null)
{
CleanupViewInternal(viewModel, oldView, context);
}
InitializeView(viewModel, view, context);
ViewInitialized?.Invoke(this, new ViewInitializedEventArgs(view, viewModel, context));
tcs.SetResult(null);
});
return(tcs.Task);
}
public virtual void MediatorShouldCallOnNavigatingOnClose()
{
bool result = false;
bool isInvoked = false;
var view = new DialogViewMock();
var vm = GetViewModel <NavigableViewModelMock>();
ViewManager.GetViewDelegate = (model, s) => view;
WindowViewMediatorBase <TView> windowMediator = Create(vm);
NavigationDispatcher.OnNavigatingFromAsync = context =>
{
isInvoked = true;
context.ShouldNotBeNull();
context.NavigationMode.ShouldEqual(NavigationMode.Back);
context.NavigationType.ShouldEqual(NavigationType.Window);
context.ViewModelFrom.ShouldEqual(vm);
return(ToolkitExtensions.FromResult(result));
};
windowMediator.ShowAsync(DataContext.Empty);
windowMediator.CloseAsync(null).Result.ShouldBeFalse();
isInvoked.ShouldBeTrue();
isInvoked = false;
result = true;
windowMediator.CloseAsync(null).Result.ShouldBeTrue();
isInvoked.ShouldBeTrue();
}
private static bool HasViewModel(object view, Type viewModelType)
{
if (view == null)
{
return(false);
}
var viewModel = ToolkitExtensions.GetDataContext(view) as IViewModel;
if (viewModel == null)
{
return(false);
}
var vmType = viewModel.GetType();
#if WINDOWS_UWP || XAMARIN_FORMS
if (!viewModelType.GetTypeInfo().IsGenericType)
#else
if (!viewModelType.IsGenericType)
#endif
{ return(vmType.Equals(viewModelType)); }
#if WINDOWS_UWP || XAMARIN_FORMS
if (!vmType.GetTypeInfo().IsGenericType)
#else
if (!vmType.IsGenericType)
#endif
{ return(false); }
return(vmType.GetGenericTypeDefinition().Equals(viewModelType.GetGenericTypeDefinition()));
}
public MultiBindingPathMembers(WeakReference observerReference, object penultimateValue, IList <IBindingMemberInfo> members)
{
PenultimateValueRef = ToolkitExtensions.GetWeakReference(penultimateValue);
_observerRef = observerReference;
_members = members;
_lastMember = _members[_members.Count - 1];
}
public Task InitializeViewAsync(IViewModel viewModel, object view, IDataContext context = null)
{
var tcs = new TaskCompletionSource <object>();
ThreadManager.InvokeOnUiThreadAsync(() =>
{
if (context == null)
{
context = DataContext.Empty;
}
view = ToolkitExtensions.GetUnderlyingView <object>(view);
var oldView = viewModel.Settings.Metadata.GetData(ViewModelConstants.View);
if (ReferenceEquals(oldView, view))
{
tcs.SetResult(null);
return;
}
if (oldView != null)
{
CleanupViewInternal(viewModel, oldView, context);
}
InitializeView(viewModel, view, context);
Action <IViewManager, IViewModel, object, IDataContext> handler = ViewInitialized;
if (handler != null)
{
handler(this, viewModel, view, context);
}
tcs.SetResult(null);
});
return(tcs.Task);
}
public Task <MessageResult> ShowAsync(string messageBoxText, string caption = "",
MessageButton button = MessageButton.Ok, MessageImage icon = MessageImage.None,
MessageResult defaultResult = MessageResult.None, IDataContext context = null)
{
bool success;
MessageBoxButton buttons = ConvertMessageBoxButtons(button, out success);
Should.BeSupported(success, "The MessageBoxAdapter doesn't support {0} value", button);
if (_threadManager.IsUiThread)
{
MessageBoxResult result = MessageBox.Show(messageBoxText, caption, buttons,
ConvertMessageBoxImages(icon),
ConvertMessageBoxResults(defaultResult));
return(ToolkitExtensions.FromResult(ConvertMessageBoxResult(result)));
}
var tcs = new TaskCompletionSource <MessageResult>();
_threadManager.InvokeOnUiThreadAsync(() =>
{
MessageBoxResult result = MessageBox.Show(messageBoxText, caption, buttons,
ConvertMessageBoxImages(icon), ConvertMessageBoxResults(defaultResult));
tcs.SetResult(ConvertMessageBoxResult(result));
});
return(tcs.Task);
}
protected override Task <IDictionary <string, IEnumerable> > ValidateInternalAsync(string propertyName, CancellationToken token)
{
if (!MemberNameEqual(propertyName, () => model => model.Login))
{
return(EmptyResult);
}
// To simulate the long-term operation.
return(Task <IDictionary <string, IEnumerable> > .Factory.StartNew(() =>
{
ToolkitExtensions.Sleep(500);
if (token.IsCancellationRequested)
{
return null;
}
if (_userRepository.GetUsers().Any(model => model != Instance && model.Login == Instance.Login))
{
return new Dictionary <string, IEnumerable>
{
{
propertyName,
$"The user with login {Instance.Login}, already exists."
}
}
}
;
return null;
}, token));
}
public static Task EnableValidationAsync <T, TValue>([NotNull] this T validatableViewModel,
[NotNull] Expression <Func <T, TValue> > getMember)
where T : IValidatorAggregator
{
Should.NotBeNull(validatableViewModel, "validatableViewModel");
return(validatableViewModel.EnableValidationAsync(ToolkitExtensions.GetMemberName(getMember)));
}
public void SetViewModel(IViewModel viewModel)
{
WeakReference[] viewModels;
lock (this)
{
if (_viewModelRef != null)
{
return;
}
_viewModelRef = ToolkitExtensions.GetWeakReference(viewModel);
if (_childViewModels == null)
{
return;
}
viewModels = _childViewModels.ToArray();
_childViewModels = null;
}
for (int i = 0; i < viewModels.Length; i++)
{
var childVm = (IViewModel)viewModels[i].Target;
if (childVm != null && !childVm.IsDisposed)
{
OnParentUpdated(childVm, viewModel);
}
}
}
public Task <bool> GoToStateAsync(object view, string stateName, bool useTransitions, IDataContext context)
{
Should.NotBeNull(view, "view");
#if WPF
var control = ToolkitExtensions.GetUnderlyingView <object>(view) as FrameworkElement;
#else
var control = ToolkitExtensions.GetUnderlyingView <object>(view) as Control;
#endif
if (control == null)
{
return(Empty.FalseTask);
}
var tcs = new TaskCompletionSource <bool>();
_threadManager.InvokeOnUiThreadAsync(() =>
{
#if WPF
var result = System.Windows.VisualStateManager.GoToState(control, stateName, useTransitions);
#elif !WINDOWSCOMMON
var result = System.Windows.VisualStateManager.GoToState(control, stateName, useTransitions);
#else
var result = Windows.UI.Xaml.VisualStateManager.GoToState(control, stateName, useTransitions);
#endif
tcs.SetResult(result);
});
return(tcs.Task);
}
public void Handle(object sender, PropertyChangedEventArgs args)
{
bool hasDeadRef = false;
var listeners = _listeners;
for (int i = 0; i < listeners.Length; i++)
{
if (i >= _size)
{
break;
}
var pair = listeners[i];
if (pair.Key.IsEmpty)
{
hasDeadRef = true;
continue;
}
if (ToolkitExtensions.MemberNameEqual(args.PropertyName, pair.Value, true))
{
if (!pair.Key.EventListener.TryHandle(sender, args))
{
hasDeadRef = true;
}
}
}
if (hasDeadRef)
{
lock (this)
Cleanup();
}
}
protected virtual IDataBinding CreateBinding([NotNull] IDataContext context, out object target, out IBindingPath targetPath)
{
IBindingSourceAccessor sourceAccessor;
var formatExpression = context.GetData(BindingBuilderConstants.MultiExpression);
var sourceDelegates = context.GetData(BindingBuilderConstants.Sources, true);
if (sourceDelegates.Count > 1 || formatExpression != null)
{
formatExpression = formatExpression ?? FormatMembersExpressionDelegate;
var sources = new IObserver[sourceDelegates.Count];
for (int index = 0; index < sourceDelegates.Count; index++)
{
sources[index] = sourceDelegates[index].Invoke(context);
}
sourceAccessor = new MultiBindingSourceAccessor(sources, formatExpression, context);
}
else
{
sourceAccessor = new BindingSourceAccessor(sourceDelegates[0].Invoke(context), context, false);
}
var binding = new DataBinding(new BindingSourceAccessor(GetBindingTarget(context, out target, out targetPath), context, true), sourceAccessor);
object source;
if (context.TryGetData(BindingBuilderConstants.Source, out source))
{
binding.Context.AddOrUpdate(BindingConstants.Source, ToolkitExtensions.GetWeakReference(source));
}
AddBehaviors(binding, context);
return(binding);
}
public WeakEventHandler(TTarget target, Action <TTarget, object, TArg> invokeAction, Delegate unsubscribeAction)
{
Should.NotBeNull(target, nameof(target));
Should.NotBeNull(invokeAction, nameof(invokeAction));
_invokeAction = invokeAction;
_unsubscribeAction = unsubscribeAction;
_targetReference = ToolkitExtensions.GetWeakReference(target);
}
private ParentObserver(FrameworkElement view)
{
_view = ServiceProvider.WeakReferenceFactory(view);
_parent = ToolkitExtensions.GetWeakReferenceOrDefault(FindParent(view), Empty.WeakReference, false);
RoutedEventHandler handler = OnChanged;
view.Loaded += handler;
view.Unloaded += handler;
}
Task <object> IViewManager.GetViewAsync(IViewModel viewModel, IDataContext dataContext)
{
if (GetViewRawDelegate == null)
{
return(ToolkitExtensions.FromResult(GetViewDelegate(viewModel, dataContext.GetData(InitializationConstants.ViewName))));
}
return(ToolkitExtensions.FromResult(GetViewRawDelegate(viewModel, dataContext)));
}
private static void Register(IBindingMemberProvider memberProvider)
{
BindingBuilderExtensions.RegisterDefaultBindingMember <Entry>(() => t => t.Text);
BindingBuilderExtensions.RegisterDefaultBindingMember <Label>(() => t => t.Text);
BindingBuilderExtensions.RegisterDefaultBindingMember <Button>("Clicked");
BindingBuilderExtensions.RegisterDefaultBindingMember <ToolbarItem>("Clicked");
BindingBuilderExtensions.RegisterDefaultBindingMember <ListView>(() => c => c.ItemsSource);
BindingBuilderExtensions.RegisterDefaultBindingMember <ProgressBar>(() => c => c.Progress);
//Element
memberProvider.Register(AttachedBindingMember
.CreateMember <Element, object>(AttachedMemberConstants.Parent, GetParentValue, SetParentValue, ObserveParentMember));
memberProvider.Register(typeof(Element), "BindingContext", BindingMemberProvider.BindingContextMember, true);
//VisualElement
var visibleMember = memberProvider.GetBindingMember(typeof(VisualElement),
ToolkitExtensions.GetMemberName <VisualElement>(() => element => element.IsVisible), true, false);
if (visibleMember != null)
{
memberProvider.Register(typeof(VisualElement), "Visible", visibleMember, true);
memberProvider.Register(AttachedBindingMember.CreateMember <VisualElement, bool>("Hidden",
(info, element) => !element.IsVisible, (info, element, arg3) => element.IsVisible = !arg3,
(info, element, arg3) => visibleMember.TryObserve(element, arg3)));
}
memberProvider.Register(AttachedBindingMember
.CreateMember <VisualElement, object>(AttachedMemberConstants.FindByNameMethod, FindByNameMemberImpl));
memberProvider.Register(AttachedBindingMember.CreateMember <VisualElement, bool>(AttachedMemberConstants.Focused, (info, element) => element.IsFocused,
(info, element, arg3) =>
{
if (arg3)
{
element.Focus();
}
else
{
element.Unfocus();
}
}, (info, element, arg3) => BindingServiceProvider.WeakEventManager.Subscribe(element, "IsFocused", arg3)));
var enabledMember = memberProvider.GetBindingMember(typeof(VisualElement),
ToolkitExtensions.GetMemberName <VisualElement>(() => element => element.IsEnabled), true, false);
if (enabledMember != null)
{
memberProvider.Register(typeof(VisualElement), AttachedMemberConstants.Enabled, enabledMember, true);
}
//Toolbar item
enabledMember = memberProvider.GetBindingMember(typeof(ToolbarItem), "IsEnabled", true, false);
if (enabledMember != null)
{
memberProvider.Register(typeof(ToolbarItem), AttachedMemberConstants.Enabled, enabledMember, true);
}
}
public WeakEventListenerWrapper(IEventListener listener)
{
if (listener.IsWeak)
{
_item = listener;
}
else
{
_item = ToolkitExtensions.GetWeakReference(listener);
}
}
