initial checkin of yaulw (locally)

WPF/KeepHidden.cs

@@ -0,0 +1,319 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Windows;
+using System.Windows.Interop;
+using System.Windows.Threading;
+using System.Timers;
+using Yaulw.Thread;
+
+namespace Yaulw.WPF
+{
+    /// <remarks>
+    /// Class used to keep WPF Windows Hidden permanently.
+    /// This should ideally be called in the Constructor of a window you want to keep hidden.
+    /// <example>
+    /// <code>
+    /// private static KeepHidden _HiddenWindow = null;
+    /// public HiddenMainWindow()
+    /// {
+    ///    // * Force this window to remain hidden indefinitly*
+    ///    _HiddenWindow = new KeepHidden(this);
+    /// }
+    /// </code>
+    /// </example>
+    /// </remarks>
+    public class KeepHidden
+    {
+        #region Private Statics
+
+        // Static Map of All our Hidden Windows
+        private static Dictionary<IntPtr, Window> s_hWndToWindowMap = new Dictionary<IntPtr, Window>();
+        private static List<Window> s_WindowList = new List<Window>();
+
+        private Window _wpfWindow = null;
+        private object _lockObj = new Object();
+
+        #endregion
+
+        #region Public Properties
+
+        /// <summary>
+        /// Get the WPF Object That is bound to this Keep Hidden Instance
+        /// </summary>
+        public Window wpfWindow { get { return _wpfWindow; } }
+
+        /// <summary>
+        /// Get the HWND Handle to the WPF Object bound to this Keep Hidden Instance
+        /// </summary>
+        public IntPtr hwndWindow 
+        {
+            get
+            {
+                if (_wpfWindow != null)
+                {
+                    WindowInteropHelper interop = new WindowInteropHelper(_wpfWindow);
+                    return interop.Handle;
+                }
+                return IntPtr.Zero;
+            }                
+        }
+
+        #endregion
+
+        #region Construction
+
+        /// <summary>
+        /// When Passing in a Wpf Window in this Construction, it will ensure that
+        /// This Window will remain hidden during it's life span. If the Window is Not Loaded
+        /// yet, call KeepHidden's Show() method to show it, after construction.
+        /// </summary>
+        /// <param name="wpfWindow">a WPF Window Object that you want to keep Hidden</param>
+        public KeepHidden(Window wpfWindow)
+        {
+            if (wpfWindow != null && !wpfWindow.IsLoaded)
+            {
+                // Assign the Load Event Handler we care about
+                wpfWindow.Loaded += new RoutedEventHandler(wpfWindow_Loaded);
+            }
+            else if (wpfWindow != null && wpfWindow.IsLoaded)
+            {
+                // Call the Loaded Event Handler Directly
+                wpfWindow_Loaded((object)wpfWindow, null);
+            }
+            else
+                throw new ArgumentException("Please pass valid WPF Window Object");
+
+            // Make sure we aren't already tracking this window
+            if (s_WindowList.Contains(wpfWindow))
+                throw new ArgumentException("WPF Window Object already Kept Hidden");
+                                 
+            // Assign remaining stuff
+            wpfWindow.Closing += new System.ComponentModel.CancelEventHandler(wpfWindow_Closing);
+            AppDomain.CurrentDomain.ProcessExit += new EventHandler(CurrentDomain_ProcessExit);
+            _wpfWindow = wpfWindow;
+
+            // Add to WPF Window List
+            s_WindowList.Add(wpfWindow);
+
+            // Call this upon construction ~Done Way before Show() get's called
+            HideWPFWindow(_wpfWindow);
+        }
+
+        #endregion
+
+        #region Public Methods
+
+        /// <summary>
+        /// Call this to execute a Show() call on the WPF Window that you want to Keep Hidden
+        /// </summary>
+        public void Show()
+        {
+            if (_wpfWindow != null && !_wpfWindow.IsLoaded)
+            {
+                lock (_lockObj)
+                {
+                    // Make sure it can't be seen or interacted with
+                    HideWPFWindow(_wpfWindow);
+
+                    // Show it
+                    _wpfWindow.Show();                    
+
+                    // Again... make sure...
+                    HideWPFWindow(_wpfWindow);
+
+                    // Hide it immediatly, make sure it can't be interacted with
+                    _wpfWindow.Hide();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Call this to execute a Show() call on the WPF Window that you want to Keep Hidden
+        /// ~However, it will delay call the show allowing the hidden window's constructor to finish
+        /// </summary>
+        /// <param name="nDelayInMilliseconds">Milliseconds to delay show the HiddenWindow (at least 250 recommended)</param>
+        public void Show(uint nDelayInMilliseconds)
+        {
+            // Calling Show() directly in the Constructor causes a .Net Run-time Crash
+            // upon first launch only. Calling it .5 seconds later does the trick of avoiding that error,
+            // because by then the object is fully constructed
+            ElapsedEventHandler DelayShowHiddenWindow = delegate(object sender, ElapsedEventArgs e)
+            {
+                Timer timer = (Timer)sender;
+                timer.Stop();
+
+                // * Show the Hidden Window *
+                Show();
+
+                timer.Dispose();
+                timer = null;
+            };
+            TTimerDisp timerDelayShowHiddenWindow = new TTimerDisp(DelayShowHiddenWindow, (int) nDelayInMilliseconds, true);
+        }
+
+        /// <summary>
+        /// Call this to execute a Close() call on the WPF Window that you previously had hidden
+        /// ~Should only call this when you are done with the Keep Hidden Object
+        /// </summary>
+        public void Close()
+        {
+            if (_wpfWindow != null && _wpfWindow.IsLoaded)
+            {
+                _wpfWindow.Close();
+                _wpfWindow = null;
+            }
+        }
+
+        #endregion
+
+        #region Public Static Methods
+
+        /// <summary>
+        /// Call this function to determine if the passed in Window is a Hidden Window Object * Tracked by KeepHidden *
+        /// </summary>
+        /// <param name="_wpfWindow">pass in a wpf window object to check</param>
+        /// <returns></returns>
+        public static bool IsHiddenWindow(Window _wpfWindow)
+        {            
+            if (_wpfWindow != null)
+            {
+                bool bIsFound = s_WindowList.Contains(_wpfWindow);
+                return bIsFound;
+            }
+            return false;
+        }
+
+        #endregion
+
+        #region Private Keep Hidden Event Handlers
+
+        /// <summary>
+        /// Called by the WPFWindow's OnLoad Event
+        /// </summary>      
+        private void wpfWindow_Loaded(object sender, RoutedEventArgs e)
+        {
+            lock (_lockObj)
+            {
+                Window wpfWindow = (Window)sender;
+                HideWPFWindow(wpfWindow);
+
+                // Add Window Source Message Hook * We'll track the hWnd for the Message Hook
+                // vie s_hWndToWindowMap
+                WindowInteropHelper interop = new WindowInteropHelper(wpfWindow);
+                s_hWndToWindowMap[interop.Handle] = wpfWindow;
+                HwndSource source = HwndSource.FromHwnd(interop.Handle);
+                source.AddHook(new HwndSourceHook(MessageHook));
+            }
+        }
+
+        /// <summary>
+        /// Called by the WPFWindow's Closing Event
+        /// </summary>
+        private void wpfWindow_Closing(object sender, System.ComponentModel.CancelEventArgs e)
+        {
+            lock (_lockObj)
+            {
+                // Delete from the hWndMap, so Message Hook
+                // Stops processing messages
+                Window wpfWindow = (Window)sender;
+                if (s_hWndToWindowMap.ContainsValue(wpfWindow))
+                {
+                    foreach (IntPtr hWnd in s_hWndToWindowMap.Keys)
+                    {
+                        if (s_hWndToWindowMap[hWnd] == wpfWindow)
+                        {
+                            s_hWndToWindowMap.Remove(hWnd);
+                            break;
+                        }
+                    }
+                }
+
+                // * Imp * Delete internal wpfWindow Reference,
+                // but DON'T Delete from the s_WindowList. Caller could still call IsHiddenWindow(),
+                // and we MUST return true if it is
+                _wpfWindow = null;
+            }
+        }
+
+        /// <summary>
+        /// Called by the Process Exiting * We want this to happen last *
+        /// This allows all unload events for each window to happen first
+        /// </summary>
+        void CurrentDomain_ProcessExit(object sender, EventArgs e)
+        {
+            // Make sure to clear all windows
+             s_hWndToWindowMap.Clear();
+
+             // Make sure to clear all windows
+             s_WindowList.Clear();
+        }
+
+        /// <summary>
+        /// This Message Hook is for the WpfWindow to absolutely ensure that it remains Hidden.
+        /// We want to make sure that it is never displayed *It can occur that explorer.exe can show it, without this hook*
+        /// ~i.e. when explorer.exe crashes, and get's restarted, it can cause inconsitencies
+        /// </summary>       
+        private IntPtr MessageHook(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
+        {
+            // Get the Proper WPF Object and make sure it is Hidden
+            if (s_hWndToWindowMap.ContainsKey(hwnd))
+            {
+                Window wpfWindow = s_hWndToWindowMap[hwnd];
+                if (wpfWindow != null)
+                    HideWPFWindow(wpfWindow);
+            }
+            handled = false;
+            return System.IntPtr.Zero;
+        }
+
+        #endregion
+
+        #region Private Hide Window Functionality
+
+        /// <summary>
+        /// * Core * 'Hiding' Function. Makes sure that the Window is and
+        /// stays hidden.
+        /// </summary>
+        /// <remarks>
+        /// Height="2" Width="2" AllowsTransparency="True" Background="{x:Null}" WindowStyle="None" WindowStartupLocation="Manual" WindowState="Normal" ResizeMode="NoResize" Foreground="{x:Null}" ShowInTaskbar="False" ShowActivated="False" Left="0" Top="0" MaxWidth="2" MaxHeight="2" MinHeight="2" MinWidth="2" Visibility="Hidden" Opacity="0" IsHitTestVisible="False" IsTabStop="False" Focusable="False" IsEnabled="False"
+        /// </remarks>
+        /// <param name="wpfWindow">a WPF window object</param>
+        private void HideWPFWindow(Window wpfWindow)
+        {
+            // Force a tiny Window in top-left corner
+            wpfWindow.Width = 2;
+            wpfWindow.Height = 2;
+            wpfWindow.MinWidth = 2;
+            wpfWindow.MinHeight = 2;
+            wpfWindow.MaxWidth = 2;
+            wpfWindow.MaxHeight = 2;
+            wpfWindow.Top = 0;
+            wpfWindow.Left = 0;
+
+            // Force transparency
+            if (!wpfWindow.IsLoaded) // must not be already loaded
+                wpfWindow.AllowsTransparency = true;
+            wpfWindow.Background = null;
+            wpfWindow.Foreground = null;
+
+            // Force no user interaction
+            wpfWindow.WindowStartupLocation = WindowStartupLocation.Manual;
+            wpfWindow.WindowState = WindowState.Normal;
+            wpfWindow.ResizeMode = ResizeMode.NoResize;
+            wpfWindow.ShowInTaskbar = false;
+            wpfWindow.ShowActivated = false;
+            wpfWindow.Visibility = Visibility.Hidden;
+            wpfWindow.IsHitTestVisible = false;
+            wpfWindow.IsTabStop = false;
+            wpfWindow.Focusable = false;
+
+            // Force Opacity
+            wpfWindow.WindowStyle = WindowStyle.None;
+            wpfWindow.Opacity = 0.0;
+        }
+
+        #endregion
+    }
+}