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); } }