private KeyValuePair<int, Window> CreateWindow(ViewModelType type, IViewModel viewModel) { this.index++; Window window; switch (type) { case ViewModelType.LoginWindow: window = new LoginWindow {DataContext = viewModel}; break; case ViewModelType.MainWindow: window = new MainWindow {DataContext = viewModel}; break; case ViewModelType.SettingsWindow: window = new SettignsWindow { DataContext = viewModel }; break; default: window = new Window { DataContext = viewModel }; break; } window.DataContext = viewModel; KeyValuePair<int, Window> keyValuePair = new KeyValuePair<int, Window>(this.index, window); this.windows.Add(keyValuePair); return keyValuePair; }
public override void Add(ToolStripItem item, IViewModel viewModel) { if (_Items == null) { _Items = new List<ToolStripItem>(); } _Items.Add(item); Pwd.M.ViewModel model = viewModel as Pwd.M.ViewModel; if (model == null) { return; } if (item is ToolStripMenuItem) { (item as ToolStripMenuItem).Checked = model.CatTreeVisible; return; } if (item is ToolStripButton) { (item as ToolStripButton).Checked = model.CatTreeVisible; return; } }
/// <summary> /// Initializes a new instance of the <see cref="RibbonWindow"/> class. /// </summary> /// <param name="viewModel">The view model.</param> public RibbonWindow(IViewModel viewModel) { var viewModelType = (viewModel != null) ? viewModel.GetType() : GetViewModelType(); if (viewModelType == null) { var viewModelLocator = ServiceLocator.Default.ResolveType<IViewModelLocator>(); viewModelType = viewModelLocator.ResolveViewModel(GetType()); if (viewModelType == null) { const string error = "The view model of the view could not be resolved. Use either the GetViewModelType() method or IViewModelLocator"; throw new NotSupportedException(error); } } _logic = new WindowLogic(this, viewModelType, viewModel); _logic.ViewModelChanged += (sender, e) => ViewModelChanged.SafeInvoke(this, e); _logic.ViewModelPropertyChanged += (sender, e) => ViewModelPropertyChanged.SafeInvoke(this, e); _logic.PropertyChanged += (sender, e) => PropertyChanged.SafeInvoke(this, e); Loaded += (sender, e) => _viewLoaded.SafeInvoke(this); Unloaded += (sender, e) => _viewUnloaded.SafeInvoke(this); DataContextChanged += (sender, e) => _viewDataContextChanged.SafeInvoke(this, new DataContextChangedEventArgs(e.OldValue, e.NewValue)); // Because the RadWindow does not close when DialogResult is set, the following code is required ViewModelChanged += (sender, e) => OnViewModelChanged(); // Call manually the first time (for injected view models) OnViewModelChanged(); SetBinding(TitleProperty, new Binding("Title")); }
public int ShowWindow(ViewModelType type, IViewModel viewModel) { KeyValuePair<int, Window> k = this.CreateWindow(type, viewModel); viewModel.WindowId = k.Key; k.Value.Show(); return k.Key; }
public CreateItemViewModel( IViewModelsFactory<IItemOverviewStepViewModel> overviewVmFactory, IViewModelsFactory<IItemPropertiesStepViewModel> propertiesVmFactory, IViewModelsFactory<IItemPricingStepViewModel> pricingVmFactory, IViewModelsFactory<IEditorialReviewViewModel> reviewVmFactory, Item item, IViewModel parentEntityVM, ICatalogEntityFactory entityFactory) { _itemModel = new ItemStepModel { InnerItem = item, ParentEntityVM = parentEntityVM, ParentWizard = this }; var allParameters = new[] { new KeyValuePair<string, object>("itemModel", _itemModel) }; // properties Step must be created first var propertiesStep = propertiesVmFactory.GetViewModelInstance(allParameters); // this step is created second, but registered first RegisterStep(overviewVmFactory.GetViewModelInstance(allParameters)); RegisterEditorialReviewStep(item, entityFactory, reviewVmFactory); // properties Step is registered third RegisterStep(propertiesStep); pricingStep4 = pricingVmFactory.GetViewModelInstance(allParameters); // this step is added or removed at RUNTIME // RegisterStep(pricingStep4); item.StartDate = DateTime.Today; }
/// <summary> /// Exports the <paramref name="viewModel" />'s view to the print or clipboard or file. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="exportMode">The export mode.</param> /// <param name="dpiX">The dpi X.</param> /// <param name="dpiY">The dpi Y.</param> /// <exception cref="System.InvalidOperationException"></exception> /// <exception cref="System.ArgumentNullException">The <paramref name="viewModel" /> is <c>null</c>.</exception> /// <remarks>If <paramref name="exportMode" /> is <see cref="ExportMode.Print" /> then the <paramref name="dpiX" /> and <paramref name="dpiY" /> argument will be ignored.</remarks> public virtual void Export(IViewModel viewModel, ExportMode exportMode = ExportMode.Print, double dpiX = 96, double dpiY = 96) { Argument.IsNotNull(() => viewModel); var view = _viewManager.GetViewsOfViewModel(viewModel).OfType<UIElement>().FirstOrDefault(); if (view == null) { string message = string.Format(CultureInfo.InvariantCulture, "There no an active view for this view model of type '{0}'", viewModel.GetType().FullName); Log.Error(message); throw new InvalidOperationException(message); } if (exportMode == ExportMode.Print) { Print(view); } else { var bitmap = CreateImageFromUIElement(view, dpiX, dpiY); #if !SILVERLIGHT if (exportMode == ExportMode.File) { SaveToFile(bitmap); } else { Clipboard.SetImage(bitmap); } #else SaveToFile(bitmap); #endif } }
protected WindowBase(IViewModel viewModel) { DataContext = viewModel; // Ghetto way to get CenterOwner to work... if (Application.Current.MainWindow != this) Owner = Application.Current.MainWindow; }
private async void AsyncMethodWithViewModel(IAsyncOperation<bool> asyncOperation, bool result, IViewModel viewModel) { bool b = await asyncOperation; b.ShouldEqual(result); ViewModel = viewModel; AsyncMethodInvoked = true; }
public override void Add(ToolStripItem item, IViewModel viewModel) { if (_Items == null) { _Items = new List<ToolStripItem>(); } _Items.Add(item); Pwd.M.ViewModel model = viewModel as Pwd.M.ViewModel; if (model == null) { return; } bool ok = model.Pattern == CPwd.PATTERN_PRO; if (item is ToolStripMenuItem) { (item as ToolStripMenuItem).Checked = ok; return; } if (item is ToolStripButton) { (item as ToolStripButton).Checked = ok; return; } }
public static void TraceViewModel(AuditAction auditAction, IViewModel viewModel) { Action<AuditAction, IViewModel> handler = TraceViewModelHandler; if (handler != null) handler(auditAction, viewModel); ServiceProvider.Tracer.TraceViewModel(auditAction, viewModel); }
public void ActivateItem(IViewModel parentViewModel) { base.ActivateItem(parentViewModel); _activatedItems.Push(parentViewModel); Refresh(); }
public void CloseItem(IViewModel parentViewModel) { DeactivateItem(parentViewModel, true); _activatedItems.Pop(); if (_activatedItems.Any()) base.ActivateItem(_activatedItems.Peek()); }
public MainWindowViewModel(ISelectDirectoryService selectDirectoryService) { _listScreen = new ListViewModel(this, selectDirectoryService); _playerScreen = new PlayerViewModel(this); CurrentScreen = _listScreen; }
/// <summary> /// Exports the <paramref name="viewModel" />'s view to the print or clipboard or file. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="exportMode">The export mode.</param> /// <param name="dpiX">The dpi X.</param> /// <param name="dpiY">The dpi Y.</param> /// <exception cref="System.InvalidOperationException"></exception> /// <exception cref="System.ArgumentNullException">The <paramref name="viewModel" /> is <c>null</c>.</exception> /// <remarks>If <paramref name="exportMode" /> is <see cref="ExportMode.Print" /> then the <paramref name="dpiX" /> and <paramref name="dpiY" /> argument will be ignored.</remarks> public virtual void Export(IViewModel viewModel, ExportMode exportMode = ExportMode.Print, double dpiX = 96, double dpiY = 96) { Argument.IsNotNull("viewModel", viewModel); var view = _viewManager.GetViewsOfViewModel(viewModel).OfType<UIElement>().FirstOrDefault(); if (view == null) { throw Log.ErrorAndCreateException < InvalidOperationException >("There no an active view for this view model of type '{0}'", viewModel.GetType().FullName); } var bitmap = CreateImageFromUIElement(view, dpiX, dpiY); if (exportMode == ExportMode.Print) { Print(bitmap); } else { #if !SILVERLIGHT if (exportMode == ExportMode.File) { SaveToFile(bitmap); } else { Clipboard.SetImage(bitmap); } #else SaveToFile(bitmap); #endif } }
public MainView() { InitializeComponent(); vm = DataContext as IViewModel; vm.OnActivate(); tabControl.SelectionChanged += Items_CurrentChanged; }
public void ReleaseViewModel(IViewModel viewModel) { if (viewModel != null) { ReleaseViewModelInstance(viewModel); } }
/// <summary> /// Initializes the <see cref="NavigatedEventArgs" />. /// </summary> public NavigatedEventArgs([NotNull]INavigationContext context, [NotNull] IViewModel viewModel) { Should.NotBeNull(context, "context"); Should.NotBeNull(viewModel, "viewModel"); _context = context; _viewModel = viewModel; }
public BindingExpression Create(IViewModel viewModel, String elementId, String targetProperty, Binding binding) { var type = viewModel.GetType(); // find property dic IDictionary<string, MemberInfo> propertyDic; if(!_typeBindingDic.TryGetValue(type, out propertyDic)) { propertyDic = new Dictionary<string, MemberInfo>(); _typeBindingDic[type] = propertyDic; } MemberInfo propertyInfo = null; if(!propertyDic.TryGetValue(targetProperty, out propertyInfo)) { // find the member... propertyInfo = type.GetMember(targetProperty).FirstOrDefault(); if(propertyInfo == null) { return null; } propertyDic[targetProperty] = propertyInfo; } var bindingExpression = new BindingExpression(binding, propertyInfo, viewModel); return bindingExpression; }
/// <summary> /// Initializes a new instance of the <see cref="ViewModelCommandManager" /> class. /// </summary> /// <param name="viewModel">The view model.</param> /// <exception cref="ArgumentNullException">The <paramref name="viewModel"/> is <c>null</c>.</exception> private ViewModelCommandManager(IViewModel viewModel) { Argument.IsNotNull("viewModel", viewModel); Log.Debug("Creating a ViewModelCommandManager for view model '{0}' with unique identifier '{1}'", viewModel.GetType().FullName, viewModel.UniqueIdentifier); _viewModel = viewModel; _viewModelType = viewModel.GetType(); _viewModel.Initialized += OnViewModelInitialized; _viewModel.PropertyChanged += OnViewModelPropertyChanged; _viewModel.Closed += OnViewModelClosed; var properties = new List<PropertyInfo>(); properties.AddRange(_viewModelType.GetPropertiesEx()); foreach (var propertyInfo in properties) { if (propertyInfo.PropertyType.ImplementsInterfaceEx(typeof(ICommand))) { _commandProperties.Add(propertyInfo); } } RegisterCommands(false); Log.Debug("Created a ViewModelCommandManager for view model '{0}' with unique identifier '{1}'", viewModel.GetType().FullName, viewModel.UniqueIdentifier); }
public VsDesignerControl(IViewModel viewModel) { DataContext = viewModel; InitializeComponent(); // wait until we're initialized to handle events viewModel.ViewModelChanged += new EventHandler(ViewModelChanged); }
public void Weave(UIElement view, IViewModel viewModel) { BindContext(view, viewModel); var namedElements = (view is ChildWindow ? GetChildWindowNamedElements(view) : GetNamedElements(view)).ToList(); BindProperties(namedElements, viewModel); BindMethods(namedElements, viewModel); }
/// <summary> /// Initializes a new instance of the <see cref="ViewModelClosedEventArgs" /> class. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="result">The result to pass to the view. This will, for example, be used as <c>DialogResult</c>.</param> /// <exception cref="ArgumentNullException">The <paramref name="viewModel"/> is <c>null</c>.</exception> public ViewModelClosedEventArgs(IViewModel viewModel, bool? result) { Argument.IsNotNull("viewModel", viewModel); ViewModel = viewModel; Result = result; }
/// <summary> /// Initializes a new instance of the <see cref="CongregatePresenter"/> class. /// </summary> /// <param name="view">The view.</param> /// <param name="stockItemView">The stock item view.</param> /// <param name="bankAccountView">The bank account view.</param> /// <param name="model">The model.</param> public CongregatePresenter(ICongregateView view, IStockItemView stockItemView, IBankAccountView bankAccountView, IViewModel model) { this._View = view; this._StockItemView = stockItemView; this._BankAccountView = bankAccountView; this._Model = model as AppDataManager; }
public override void OnPropertyChanged(IViewModel viewModel, string propertyName, object newValue) { OnPropertyChangedCalled = true; OnPropertyChangedViewModel = viewModel; OnPropertyChangedPropertyName = propertyName; OnPropertyChangedNewValue = newValue; }
public void OnToggleViewCommand() { if (_CurrentViewModel.Equals(_CustomerListViewModel)) CurrentViewModel = _CustomerViewModel; else CurrentViewModel = _CustomerListViewModel; }
public Locator() { if (Windows.ApplicationModel.DesignMode.DesignModeEnabled) ViewModel = new FakeViewModel(); else ViewModel = new ViewModel(); }
public override void OnPropertyChanging(IViewModel viewModel, string propertyName, object oldValue) { OnPropertyChangingCalled = true; OnPropertyChangingViewModel = viewModel; OnPropertyChangingPropertyName = propertyName; OnPropertyChangingOldValue = oldValue; }
public void Initialise(IViewModel viewModel) { ViewModel = viewModel; var supportClosing = ViewModel as ISupportClosing; if (supportClosing != null) { ShowClose = true; IDisposable closing = null; closing = supportClosing.ClosingStrategy.Closed .Subscribe(x => { if (!_viewModelIsClosed) { _viewModelIsClosed = true; ClosingStrategy.Close(); } if (closing != null) { closing.Dispose(); } }); } }
public static EventHandler SetContext(IViewModel viewModel) { return (o,e) => { (o as FrameworkElement).DataContext = viewModel; }; }
/// <summary> /// Initializes a new instance of the <see cref="WindowLogic"/> class. /// </summary> /// <param name="targetWindow">The window this provider should take care of.</param> /// <param name="viewModelType">Type of the view model.</param> /// <param name="viewModel">The view model to inject.</param> /// <exception cref="ArgumentNullException">The <paramref name="targetWindow"/> is <c>null</c>.</exception> public WindowLogic(IView targetWindow, Type viewModelType = null, IViewModel viewModel = null) : base(targetWindow, viewModelType, viewModel) { var targetWindowType = targetWindow.GetType(); string eventName; var closedEvent = targetWindowType.GetEventEx("Closed"); if (closedEvent != null) { eventName = "Closed"; _dynamicEventListener = new DynamicEventListener(targetWindow, "Closed", this, "OnTargetWindowClosed"); } else { eventName = "Unloaded"; _dynamicEventListener = new DynamicEventListener(targetWindow, "Unloaded", this, "OnTargetWindowClosed"); } _targetWindowClosedEventName = eventName; Log.Debug("Using '{0}.{1}' event to determine window closing", targetWindowType.FullName, eventName); }
/// <summary> /// Registers a view model instance with the manager. All view models must register themselves to the manager. /// </summary> /// <param name="viewModel">The view model to register.</param> /// <exception cref="ArgumentNullException">The <paramref name="viewModel"/> is <c>null</c>.</exception> public void RegisterViewModelInstance(IViewModel viewModel) { RegisterViewModelInstanceInternal(viewModel); }
public static IViewModel GetViewModel([NotNull] this IViewModelProvider viewModelProvider, [NotNull] Type viewModelType, IViewModel parentViewModel = null, ObservationMode?observationMode = null, params DataConstantValue[] parameters) { return(GetViewModel(viewModelProvider, viewModelType, MergeParameters(parentViewModel, observationMode, parameters))); }
public static IViewModel GetParentViewModel([NotNull] this IViewModel viewModel) { Should.NotBeNull(viewModel, nameof(viewModel)); return((IViewModel)viewModel.Settings.Metadata.GetData(ViewModelConstants.ParentViewModel)?.Target); }
public static IAsyncOperation GetCurrentNavigationOperation([NotNull] this IViewModel viewModel) { Should.NotBeNull(viewModel, nameof(viewModel)); return(viewModel.Settings.Metadata.GetData(ViewModelConstants.CurrentNavigationOperation)); }
public static Guid GetViewModelId(this IViewModel viewModel) { return(ViewModelProvider.GetOrAddViewModelId(viewModel)); }
public static void InvalidateCommands(this IViewModel viewModel) { Should.NotBeNull(viewModel, nameof(viewModel)); viewModel.Publish(viewModel, StateChangedMessage.Empty); }
public static T GetViewModel <T>([NotNull] this IViewModelProvider viewModelProvider, IViewModel parentViewModel = null, ObservationMode?observationMode = null, params DataConstantValue[] parameters) where T : IViewModel { return(GetViewModel <T>(viewModelProvider, MergeParameters(parentViewModel, observationMode, parameters))); }
public static void RemoveClosedHandler([NotNull] this IViewModel viewModel, EventHandler <IViewModel, ViewModelClosedEventArgs> handler) { viewModel.UpdateEventHandler(ViewModelConstants.ClosedEvent, handler, false); }
public static IAsyncOperation ShowAsync([NotNull] this IViewModel viewModel, string viewName, IDataContext context = null) { return(viewModel.ShowAsync(null, viewName, context)); }
public static T GetViewModel <T>([NotNull] this IViewModelProvider viewModelProvider, [NotNull] GetViewModelDelegate <T> getViewModelGeneric, IViewModel parentViewModel = null, ObservationMode?observationMode = null, params DataConstantValue[] parameters) where T : class, IViewModel { return(GetViewModel(viewModelProvider, getViewModelGeneric, MergeParameters(parentViewModel, observationMode, parameters))); }
public NavigationEventArgs(IViewModel viewModelToNavigateTo) { this.ViewModelToNavigateTo = viewModelToNavigateTo; }
public static void AddClosingHandler([NotNull] this IViewModel viewModel, EventHandler <IViewModel, ViewModelClosingEventArgs> handler) { viewModel.UpdateEventHandler(ViewModelConstants.ClosingEvent, handler, true); }
/// <summary> /// Initializes a new instance of the <see cref="FooViewModelView"/> class. /// </summary> /// <param name="viewModel"> /// The view model. /// </param> public FooViewModelView(IViewModel viewModel) : base(viewModel) { }
public static IAsyncOperation ShowAsync([NotNull] this IViewModel viewModel, params DataConstantValue[] parameters) { return(viewModel.ShowAsync(parameters == null ? null : new DataContext(parameters))); }
public void ChangeCurrentView(ViewBase newView, IViewModel sender) { CurrentView = newView; UpdateCurrentView(sender); }
/// <summary> /// Initializes a new instance of the <see cref="FooParentViewModelView"/> class. /// </summary> /// <param name="viewModel"> /// The view model. /// </param> public FooParentViewModelView(IViewModel viewModel) : base(viewModel) { }
/// <summary> /// Initializes a new instance of the <see cref="DataWindow"/> class. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="mode"><see cref="DataWindowMode"/>.</param> /// <param name="additionalButtons">The additional buttons.</param> /// <param name="defaultButton">The default button.</param> /// <param name="setOwnerAndFocus">if set to <c>true</c>, set the main window as owner window and focus the window.</param> /// <param name="infoBarMessageControlGenerationMode">The info bar message control generation mode.</param> /// <param name="focusFirstControl">if set to <c>true</c>, the first control will get the focus.</param> public DataWindow(IViewModel viewModel, DataWindowMode mode, IEnumerable <DataWindowButton> additionalButtons = null, DataWindowDefaultButton defaultButton = DataWindowDefaultButton.OK, bool setOwnerAndFocus = true, InfoBarMessageControlGenerationMode infoBarMessageControlGenerationMode = InfoBarMessageControlGenerationMode.Inline, bool focusFirstControl = true) { if (CatelEnvironment.IsInDesignMode) { return; } // Set window style (WPF doesn't allow styling on root elements of XAML files, too bad) // For more info, see http://social.msdn.microsoft.com/Forums/en-US/wpf/thread/3059c0e4-c372-4da2-b384-28f271feef05/ SetResourceReference(StyleProperty, typeof(DataWindow)); Mode = mode; DefaultButton = defaultButton; _infoBarMessageControlGenerationMode = infoBarMessageControlGenerationMode; this.FixBlurriness(); SizeToContent = SizeToContent.WidthAndHeight; ShowInTaskbar = false; ResizeMode = ResizeMode.NoResize; WindowStartupLocation = WindowStartupLocation.CenterOwner; this.ApplyIconFromApplication(); ThemeHelper.EnsureCatelMvvmThemeIsLoaded(); _logic = new WindowLogic(this, null, viewModel); _logic.TargetViewPropertyChanged += (sender, e) => { // Do not call this for ActualWidth and ActualHeight WPF, will cause problems with NET 40 // on systems where NET45 is *not* installed if (!string.Equals(e.PropertyName, nameof(ActualWidth), StringComparison.InvariantCulture) && !string.Equals(e.PropertyName, nameof(ActualHeight), StringComparison.InvariantCulture)) { PropertyChanged?.Invoke(this, e); } }; _logic.ViewModelClosedAsync += OnViewModelClosedAsync; _logic.ViewModelChanged += (sender, e) => RaiseViewModelChanged(); _logic.ViewModelPropertyChanged += (sender, e) => { OnViewModelPropertyChanged(sender, e); ViewModelPropertyChanged?.Invoke(this, e); }; Loaded += (sender, e) => { _viewLoaded?.Invoke(this, EventArgs.Empty); OnLoaded(e); }; Unloaded += (sender, e) => { _viewUnloaded?.Invoke(this, EventArgs.Empty); OnUnloaded(e); }; SetBinding(TitleProperty, new Binding("Title")); if (additionalButtons != null) { foreach (var button in additionalButtons) { _buttons.Add(button); } } CanClose = true; CanCloseUsingEscape = true; Loaded += (sender, e) => Initialize(); DataContextChanged += (sender, e) => _viewDataContextChanged?.Invoke(this, new DataContextChangedEventArgs(e.OldValue, e.NewValue)); // #1150 Subscribe in dispatcher to allow derived types to be the first handler Dispatcher.BeginInvoke(() => { Closing += OnDataWindowClosing; }); _focusFirstControl = focusFirstControl; if (setOwnerAndFocus) { this.SetOwnerWindowAndFocus(focusFirstControl: focusFirstControl); } else if (focusFirstControl) { this.FocusFirstControl(); } }
/// <summary> /// Initializes a new instance of the <see cref="NotifyPropertyChangedBase" /> class. /// </summary> public WindowViewMediator([NotNull] IViewModel viewModel, [NotNull] IThreadManager threadManager, [NotNull] IViewManager viewManager, [NotNull] IOperationCallbackManager callbackManager) : base(viewModel, threadManager, viewManager, callbackManager) { }
public virtual void OnViewModelChanged(IViewModel newValue) { Binder.Unbind(); Binder.Bind(newValue); }
public void Register(IViewModel viewModel) { ViewModelList.Add(viewModel); }
public ViewModelPreservedEventArgs(IViewModel viewModel) : base(viewModel) { }
/// <summary> /// Initializes a new instance of the <see cref="DataWindow"/> class. /// </summary> /// <param name="viewModel">The view model.</param> /// <remarks> /// Explicit constructor with view model injection, required for <see cref="Activator.CreateInstance(System.Type)"/> which /// does not seem to support default parameter values. /// </remarks> public DataWindow(IViewModel viewModel) : this(viewModel, DataWindowMode.OkCancel) { // Do not remove this constructor, see remarks }
// ----- public override void ActivateItem(IViewModel item) { Title = item.WindowTitle; base.ActivateItem(item); }
public Task Push(IViewModel viewModel, bool animated) { return(Push(_pagePresenter.Page(viewModel), viewModel, animated)); }
public static bool?ShowModalWindow(Window view, IViewModel viewModel) { viewModel.Window = view; view.DataContext = viewModel; return(view.ShowDialog()); }
/// <inheritdoc /> public bool Predicate(IViewModel viewModel) { return(Key.IsInstanceOfType(viewModel)); }
/// <summary> /// Shows a window that is registered with the specified view model in a non-modal state. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="completedProc"> /// The callback procedure that will be invoked as soon as the window is closed. This value can /// be <c>null</c>. /// </param> /// <returns> /// <c>true</c> if the popup window is successfully opened; otherwise <c>false</c>. /// </returns> /// <exception cref="ArgumentNullException">The <paramref name="viewModel" /> is <c>null</c>.</exception> /// <exception cref="WindowNotRegisteredException"> /// The <paramref name="viewModel" /> is not registered by the /// <see cref="Register(string,System.Type,bool)" /> method first. /// </exception> public async Task <bool?> ShowAsync(IViewModel viewModel, EventHandler <UICompletedEventArgs> completedProc = null) { Argument.IsNotNull(nameof(viewModel), viewModel); bool?result = null; var viewModelType = viewModel.GetType(); var resolvedView = _viewLocator.ResolveView(viewModelType); var view = (View)_typeFactory.CreateInstance(resolvedView); if (view is IView) { (view as IView).DataContext = viewModel; } else { view.BindingContext = viewModel; } var okButton = new Button { Text = _languageService.GetString("OK") }; okButton.Clicked += (sender, args) => { result = true; OnOkButtonClicked(viewModel, completedProc); }; var cancelButton = new Button { Text = _languageService.GetString("Cancel") }; cancelButton.Clicked += (sender, args) => { result = false; OnCancelButtonClicked(viewModel, completedProc); }; var dataErrorInfo = viewModel as INotifyDataErrorInfo; if (dataErrorInfo != null) { Action checkIfViewModelHasErrors = () => okButton.IsEnabled = !dataErrorInfo.HasErrors; viewModel.PropertyChanged += (sender, args) => checkIfViewModelHasErrors(); checkIfViewModelHasErrors(); } ////TODO: Improve the layout. var buttonsStackLayout = new StackLayout { Orientation = StackOrientation.Horizontal, HorizontalOptions = LayoutOptions.Center }; buttonsStackLayout.Children.Add(okButton); buttonsStackLayout.Children.Add(cancelButton); var contentLayout = new StackLayout(); contentLayout.Children.Add(view); contentLayout.Children.Add(buttonsStackLayout); if (!await TryDisplayAsPopupAsync(viewModel, completedProc, contentLayout)) { await DisplayUsingNavigationAsync(viewModel, completedProc, contentLayout); } return(result); }
public static bool?ShowModalWindow <TWindow>(IViewModel viewModel) where TWindow : Window, new() { var view = new TWindow(); return(ShowModalWindow(view, viewModel)); }
/// <summary> /// Shows a window that is registered with the specified view model in a non-modal state. /// </summary> /// <param name="viewModel">The view model.</param> /// <param name="completedProc"> /// The callback procedure that will be invoked as soon as the window is closed. This value can /// be <c>null</c>. /// </param> /// <returns> /// <c>true</c> if the popup window is successfully opened; otherwise <c>false</c>. /// </returns> /// <exception cref="ArgumentNullException">The <paramref name="viewModel" /> is <c>null</c>.</exception> /// <exception cref="WindowNotRegisteredException"> /// The <paramref name="viewModel" /> is not registered by the /// <see cref="Register(string,System.Type,bool)" /> method first. /// </exception> public bool?Show(IViewModel viewModel, EventHandler <UICompletedEventArgs> completedProc = null) { return(ShowAsync(viewModel, completedProc).Result); }
public void BindModel(IViewModel <TestModel> vm) { BindModelCalled = true; }