Yaulw/Thread/DispatcherThread.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Sys = System.Threading;
using System.Reflection;
using Yaulw.WPF;
using System.Threading;
using System.Windows.Threading;
using Yaulw.Other;

namespace Yaulw.Thread
{
    /// <summary>
    /// 
    /// </summary>
    public enum DispatcherThreatType
    {
        WPF,
        //   Winforms  // ~Not implmented
        //   Silverlight? // ~Not implemented
    }

    /// <summary>
    /// 
    /// </summary>
    public class WindowType
    {
        public Type T;
        public Enum Key;
        public bool IsSingleton;
        public bool IsPerformanceLoaded;

        public WindowType(Type t, Enum Key, bool IsSingleton, bool IsPerformanceLoaded)
        {
            this.T = t;
            this.Key = Key;
            this.IsSingleton = IsSingleton;
            this.IsPerformanceLoaded = IsPerformanceLoaded;
        }
    }

    /// <summary>
    /// 
    /// </summary>
    public class WindowAttributes
    {
        public IntPtr hWndOwner;
        public uint Height;
        public uint Width;
        public int Top;
        public int Left;
        public string Title;

        public WindowAttributes(IntPtr hWndOwner, uint Height, uint Width, int Top, int Left, string Title)
        {
            this.hWndOwner = hWndOwner;
            this.Height = Height;
            this.Width = Width;
            this.Top = Top;
            this.Left = Left;
            this.Title = Title;
        }

        public WindowAttributes(IntPtr hWndOwner, int Top, int Left)
        {
            this.hWndOwner = hWndOwner;
            this.Height = 0;
            this.Width = 0;
            this.Top = Top;
            this.Left = Left;
            this.Title = String.Empty;
        }

        public WindowAttributes(IntPtr hWndOwner)
        {
            this.hWndOwner = hWndOwner;
            this.Height = 0;
            this.Width = 0;
            this.Top = int.MinValue;
            this.Left = int.MinValue;
            this.Title = String.Empty;
        }

    }

    #region Window Manager Definition

    /// <summary>
    /// Abstract Base Class all Window Managers must inherit from.
    /// 
    /// </summary>
    public abstract class WindowManager : IDisposable
    {
        #region Private Members

        private Dictionary<WindowType, List<object>> s_WindowsToManage = new Dictionary<WindowType, List<object>>();

        #endregion

        #region Construction

        /// <summary>
        /// Construct a Window Manager Object
        /// </summary>
        /// <param name="dispatcher">Thread Dispatcher Object</param>
        /// <param name="windowTypes">Window Types this WindowManager is managing</param>
        /// <param name="PerformanceLoad">true, to load performance enabled windows upon construction</param>
        public WindowManager(Dispatcher dispatcher, WindowType[] windowTypes, bool PerformanceLoad)
        {
            Dispatcher = dispatcher;
            WindowTypes = windowTypes;
            if (Dispatcher == null)
                throw new ArgumentException("dispatcher can't be null");
            if (windowTypes == null || windowTypes.Length < 1)
                throw new ArgumentException("windowTypes can't be null or empty");

            // Add All Window Types
            foreach (WindowType type in windowTypes)
            {
                // Add the Type to be managed
                AddWindowTypeToManage(type);

                // perform performance optimization
                if (PerformanceLoad && type.IsPerformanceLoaded)
                {
                    object o = CreateInstance(type);
                    AddObject(type, o);
                }
            }
        }

        #endregion

        #region Public Properties

        /// <summary>
        /// Returns the Dispatcher Thread responsible for this Window Manager
        /// </summary>
        public Dispatcher Dispatcher { get; private set; }

        /// <summary>
        /// Returns all the Window Types that have been set to be managed by this Window Manager
        /// </summary>
        public WindowType[] WindowTypes { get; private set; }

        #endregion

        #region Protected Common Window Object Operations

        /// <summary>
        /// Create a new Object Instance of type
        /// </summary>
        /// <param name="window">type of object to create</param>
        /// <returns>a new object for type, or null</returns>
        protected object CreateInstance(WindowType window)
        {
            object o = null;
            if (window != null)
                o = Activator.CreateInstance(window.T);
            return o;
        }

        /// <summary>
        /// Create a new Object Instance of type
        /// </summary>
        /// <param name="windowKey">type of object to create</param>
        /// <returns>a new object for type, or null</returns>
        protected object CreateInstance(Enum windowKey)
        {
            return CreateInstance(GetType(windowKey));
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="windowKey"></param>
        /// <returns></returns>
        protected List<object> GetObjects(Enum windowKey)
        {
            foreach (WindowType type in s_WindowsToManage.Keys)
            {
                if (type.Key.ToString() == windowKey.ToString())
                    return s_WindowsToManage[type];
            }
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="window"></param>
        /// <returns></returns>
        protected List<object> GetObjects(WindowType window)
        {
            foreach (WindowType type in s_WindowsToManage.Keys)
            {
                if (type.Key.ToString() == window.Key.ToString())
                    return s_WindowsToManage[type];
            }
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="windowKey"></param>
        /// <returns></returns>
        protected WindowType GetType(Enum windowKey)
        {
            foreach (WindowType type in s_WindowsToManage.Keys)
            {
                if (type.Key.ToString() == windowKey.ToString())
                    return type;
            }
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="window"></param>
        /// <param name="o"></param>
        /// <returns></returns>
        protected bool AddObject(WindowType window, object o)
        {
            if (AddWindowTypeToManage(window))
            {
                List<object> objects = GetObjects(window);
                if (objects.Count == 0)
                {
                    objects.Add(o);
                    return true;
                }
                else if (objects.Count > 0 && !window.IsSingleton)
                {
                    objects.Add(o);
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="windowKey"></param>
        /// <param name="o"></param>
        /// <returns></returns>
        protected bool AddObject(Enum windowKey, object o)
        {
            WindowType type = GetType(windowKey);
            if (type != null)
            {
                List<object> objects = GetObjects(windowKey);
                if (objects.Count == 0)
                {
                    objects.Add(o);
                    return true;
                }
                else if (objects.Count > 0 && !type.IsSingleton)
                {
                    objects.Add(o);
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="window"></param>
        /// <returns></returns>
        protected bool DeleteObject(WindowType window)
        {
            List<object> objects = GetObjects(window);
            if (objects != null && objects.Count > 0)
            {
                int nIndex = objects.Count - 1;
                if (objects[nIndex] is IDisposable)
                    ((IDisposable)objects[nIndex]).Dispose();
                objects.RemoveAt(nIndex);
                return true;
            }
            return false;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="windowKey"></param>
        /// <returns></returns>
        protected bool DeleteObject(Enum windowKey)
        {
            List<object> objects = GetObjects(windowKey);
            if (objects != null && objects.Count > 0)
            {
                int nIndex = objects.Count - 1;
                if (objects[nIndex] is IDisposable)
                    ((IDisposable)objects[nIndex]).Dispose();
                objects.RemoveAt(nIndex);
                return true;
            }
            return false;
        }

        /// <summary>
        /// 
        /// </summary>
        protected void ClearAllObjects()
        {
            // Iterate thru all objects and call dispose on them if they support it,
            // then clear main dictionary
            foreach (WindowType type in s_WindowsToManage.Keys)
                while (DeleteObject(type)) ;

            s_WindowsToManage.Clear();
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="window"></param>
        /// <returns></returns>
        protected bool AddWindowTypeToManage(WindowType window)
        {
            if (window != null && !IsWindowTypeManaged(window))
                s_WindowsToManage[window] = new List<object>();

            return (IsWindowTypeManaged(window));
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="window"></param>
        /// <returns></returns>
        protected bool IsWindowTypeManaged(WindowType window)
        {
            if (window != null)
            {
                foreach (WindowType type in s_WindowsToManage.Keys)
                {
                    if (type.Key.ToString() == window.Key.ToString())
                        return true;
                }
            }
            return false;
        }

        #endregion

        #region Abtract Methods

        public delegate object ShowDelegate(Enum windowKey, WindowAttributes attributes, object tag);
        public abstract object ShowWindow(Enum windowKey, WindowAttributes attributes, object tag);
        public abstract object ShowDialog(Enum windowKey, WindowAttributes attributes, object tag);

        public delegate bool HideCloseDelegate(Enum windowKey);
        public abstract bool HideWindow(Enum windowKey);
        public abstract bool CloseWindow(Enum windowKey);

        public delegate bool ActionDelegate(Enum windowKey, DelegateCollection.Bool_Param1_Window_Func action);
        public abstract bool RunAction(Enum windowKey, DelegateCollection.Bool_Param1_Window_Func action);

        public abstract void Dispose();

        #endregion

        #region Public Methods

        /// <summary>
        /// Get All Window Objects for a Window, in a readonly fashion
        /// </summary>
        /// <param name="windowKey"></param>
        /// <returns></returns>
        public object[] GetAllWindowObjectsForWindow(Enum windowKey)
        {
            List<object> objects = GetObjects(windowKey);
            if (objects != null)
                return objects.ToArray();
            else
                return null;
        }

        #endregion
    }

    #endregion

    #region Dispatcher Thread

    /// <summary>
    /// 
    /// </summary>
    static class DispatcherThread
    {
        #region Private Static Members

        private static Sys.Thread s_DispatcherThread = null;
        private static bool s_DispatcherThreadIsInitialized = false;

        private static WPFWindowManager s_wpfWindowManager = null;
        private static DispatcherThreatType s_useWindowManagerType = DispatcherThreatType.WPF;
        private static WindowType[] s_windowTypes = null;
        private static bool s_PerformPerformanceLoad = false;

        #endregion

        #region Private Static Methods

        /// <summary>
        /// Message Loop Thread for ButtonForm
        /// </summary>        
        private static void ThreadProc()
        {
            // Create WindowManager Object on this thread *Allow global access to the object*
            if (s_useWindowManagerType == DispatcherThreatType.WPF)
                s_wpfWindowManager = new WPFWindowManager(Dispatcher.CurrentDispatcher, s_windowTypes, s_PerformPerformanceLoad);

            s_DispatcherThreadIsInitialized = true; // always set to true to allow caller to exit out
            if (s_wpfWindowManager != null)
            {
                //Enter Dispatcher Message Loop
                System.Windows.Threading.Dispatcher.Run();
            }
        }

        #endregion

        #region Public Static Methods

        /// <summary>
        /// Retrieve the Window Manager for this Dispatcher Thread
        /// </summary>
        /// <returns>a valid window Manager or null, if none</returns>
        public static WindowManager GetWMForDispatcher()
        {
            if (s_DispatcherThreadIsInitialized)
            {
                if (s_useWindowManagerType == DispatcherThreatType.WPF && s_wpfWindowManager != null)
                    return s_wpfWindowManager;
            }
            return null;
        }

        /// <summary>
        /// Use this function to start the Dispatcher ThreadProc(above), if needed. COM+ can shutdown the thread anytime,
        /// we need to make sure that the thread is alive BEFORE calling WindowManager
        /// </summary>
        public static void Start(DispatcherThreatType threatType, WindowType[] windowTypes, bool PerformPerformanceLoad, bool bWait)
        {
            if (s_DispatcherThread != null && s_DispatcherThread.IsAlive)
            {
                return;
            }
            else
            {
                s_DispatcherThreadIsInitialized = false;

                // Specify Thread Attributes
                s_useWindowManagerType = threatType;
                s_windowTypes = windowTypes;
                s_PerformPerformanceLoad = PerformPerformanceLoad;

                // Start a new Thread so it can become the Message Loop
                s_DispatcherThread = new Sys.Thread(new Sys.ThreadStart(DispatcherThread.ThreadProc));

                // GUI components require the thread to be STA; otherwise throws an error
                s_DispatcherThread.SetApartmentState(ApartmentState.STA);
                s_DispatcherThread.Start();

                // Make sure the Application Object is running 
                // (COM will eventually just time out otherwise)
                if (bWait) // Syncronous call
                {
                    while (!s_DispatcherThreadIsInitialized)
                        System.Threading.Thread.Sleep(20);
                }
            }
        }

        /// <summary>
        /// Terminates all ButtonForm Objects and the Message Dispatcher Thread *do this only on shutdown*
        /// </summary>
        public static void Stop()
        {
            if (s_DispatcherThreadIsInitialized)
            {
                // Enforce that all WindowManagers support IDispose
                if (s_wpfWindowManager != null)
                {
                    s_wpfWindowManager.Dispose();
                    s_wpfWindowManager = null;
                }
                s_DispatcherThread.Abort();
                s_DispatcherThreadIsInitialized = false;
                s_DispatcherThread = null;
            }
        }

        #endregion
    }

    #endregion
}