ViewModelBase.cs

/* ViewModelBase.cs
 * part of Daniel's XL Toolbox NG
 * 
 * Copyright 2014-2018 Daniel Kraus
 * 
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *     http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
using System;
using System.ComponentModel;
using System.Windows;
using System.Windows.Input;
using System.Threading;
using System.Windows.Threading;
using Bovender.Extensions;
using System.Threading.Tasks;

namespace Bovender.Mvvm.ViewModels
{
    public abstract class ViewModelBase : INotifyPropertyChanged
    {
        #region Public properties

        public virtual string DisplayString
        {
            get
            {
                return _displayString;
            }
            set
            {
                if (value != _displayString)
                {
                    _displayString = value;
                    OnPropertyChanged("DisplayString");
                }
            }
        }

        public bool IsSelected
        {
            get
            {
                return _isSelected;
            }
            set
            {
                _isSelected = value;
                OnPropertyChanged("IsSelected");
            }
        }

        public Dispatcher ViewDispatcher { get; set; }

        #endregion

        #region Public methods

        public bool IsViewModelOf(object model)
        {
            object wrappedObject = RevealModelObject();
            if (model == null || wrappedObject == null)
            {
                return false;
            }
            else
            {
                return wrappedObject.Equals(model);
            }
        }

        #endregion

        #region Public injectors

        public Window InjectInto<T>() where T : Window, new()
        {
            T view = new T();
            return InjectInto(view);
        }

        public Window InjectInto(Window view)
        {
            if (view != null)
            {
                EventHandler h = null;
                h = (sender, args) =>
                {
                    this.RequestCloseView -= h;
                    view.Dispatcher.BeginInvoke(new Action(() =>
                    {
                        view.DataContext = null;
                        view.Close();
                    }));
                };
                this.RequestCloseView += h;
                view.DataContext = this;
                ViewDispatcher = view.Dispatcher;
            }
            return view;
        }

        public void InjectAndShowInThread<T>(IntPtr ownerForm) where T: Window, new()
        {
            Thread t = new Thread(() =>
            {
                T view = new T();
                EventHandler h = null;
                h = (sender, args) =>
                {
                    this.RequestCloseView -= h;
                    // view.Close();
                    view.Dispatcher.Invoke(new Action(view.Close));
                    view.Dispatcher.InvokeShutdown();
                };
                this.RequestCloseView += h;
                ViewDispatcher = view.Dispatcher;
                view.DataContext = this;
                // Must shut down the Dispatcher, but this has been moved from
                // the Closed event of the view to the RequestCloseView event
                // of the view model in order to prevent premature termination
                // of the thread if there are other views that this view model
                // has been injected into.
                // view.Closed += (sender, args) => view.Dispatcher.InvokeShutdown();
                view.ShowInForm(ownerForm);
                System.Windows.Threading.Dispatcher.Run();
            });
            t.SetApartmentState(ApartmentState.STA);
            t.Start();
        }

        public void InjectAndShowInThread<T>() where T: Window, new()
        {
            InjectAndShowInThread<T>(IntPtr.Zero);
        }

        public void InjectAndShowDialogInThread<T>(IntPtr ownerForm) where T : Window, new()
        {
            Thread t = new Thread(() =>
            {
                T view = new T();
                EventHandler h = null;
                h = (sender, args) =>
                {
                    this.RequestCloseView -= h;
                    // view.Close();
                    view.Dispatcher.Invoke(new Action(view.Close));
                    view.Dispatcher.InvokeShutdown();
                };
                this.RequestCloseView += h;
                ViewDispatcher = view.Dispatcher;
                view.DataContext = this;
                // Must shut down the Dispatcher, but this has been moved from
                // the Closed event of the view to the RequestCloseView event
                // of the view model in order to prevent premature termination
                // of the thread if there are other views that this view model
                // has been injected into.
                // view.Closed += (sender, args) => view.Dispatcher.InvokeShutdown();
                view.ShowDialogInForm(ownerForm);
                // System.Windows.Threading.Dispatcher.Run();
            });
            t.SetApartmentState(ApartmentState.STA);
            t.Start();
        }

        #endregion

        #region Public (abstract) methods

        public abstract object RevealModelObject();

        #endregion

        #region Events

        public event EventHandler RequestCloseView;

        #endregion

        #region Commands

        public ICommand CloseViewCommand
        {
            get
            {
                if (_closeViewCommand == null)
                {
                    _closeViewCommand = new DelegatingCommand(
                        parameter => { DoCloseView(); },
                        parameter => { return CanCloseView(); }
                        );
                };
                return _closeViewCommand;
            }
        }

        #endregion

        #region Constructor

        protected ViewModelBase()
        {
            // Capture the current dispatcher to enable
            // asynchronous operations that a view can
            // react to dispite running in another thread.
            Dispatcher = Dispatcher.CurrentDispatcher;

            if (SynchronizationContext.Current != null)
            {
                SyncContext = TaskScheduler.FromCurrentSynchronizationContext();
            }
        }

        #endregion

        #region INotifyPropertyChanged interface

        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

        #region Protected methods

        protected virtual void OnPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
            }
        }

        protected virtual bool CanCloseView()
        {
            return true;
        }

        protected virtual void DoCloseView()
        {
            if (RequestCloseView != null && CanCloseView())
            {
                RequestCloseView(this, EventArgs.Empty);
            }
        }

        protected CancellationToken Dispatch(Action action)
        {
            if (SyncContext == null)
            {
                Logger.Info("Dispatch: Dispatching with dispatcher");
                Dispatcher.Invoke(action);
                return CancellationToken.None;
            }
            else
            {
                Logger.Info("Dispatch: Dispatching on current synchronization context");
                // TaskScheduler context = TaskScheduler.FromCurrentSynchronizationContext();
                CancellationToken token = new CancellationToken();
                Task.Factory.StartNew(action, token, TaskCreationOptions.None, SyncContext);
                return token;
            }
        }

        #endregion

        #region Protected properties

        protected Dispatcher Dispatcher { get; private set; }

        protected TaskScheduler SyncContext { get; private set; }

        #endregion

        #region Private fields

        private string _displayString;
        private DelegatingCommand _closeViewCommand;
        private bool _isSelected;

        #endregion

        #region Class logger

        private static NLog.Logger Logger { get { return _logger.Value; } }

        private static readonly Lazy<NLog.Logger> _logger = new Lazy<NLog.Logger>(() => NLog.LogManager.GetCurrentClassLogger());

        #endregion
    }
}