Add comments

Author: justcoding121

EventHook/ApplicationWatcher.cs

@@ -9,13 +9,20 @@
 
 namespace EventHook
 {
+    /// <summary>
+    /// An enum for the type of application event
+    /// </summary>
     public enum ApplicationEvents
     {
         Launched,
         Closed,
         Activated
 
     }
+
+    /// <summary>
+    /// An object that holds information on application event
+    /// </summary>
     public class WindowData
     {
         public IntPtr HWnd;
@@ -26,12 +33,19 @@ public class WindowData
         public string AppTitle { get; set; }
     }
 
+    /// <summary>
+    /// An event argument object send to user
+    /// </summary>
     public class ApplicationEventArgs : EventArgs
     {
         public WindowData ApplicationData { get; set; }
         public ApplicationEvents Event { get; set; }
     }
 
+    /// <summary>
+    /// A wrapper around shell hook to hook application window change events
+    /// Uses a producer-consumer pattern to improve performance and to avoid operating system forcing unhook on delayed user callbacks
+    /// </summary>
     public class ApplicationWatcher
     {
         /*Application history*/
@@ -45,6 +59,9 @@ public class ApplicationWatcher
 
         public static event EventHandler<ApplicationEventArgs> OnApplicationWindowChange;
 
+        /// <summary>
+        /// Start to watch
+        /// </summary>
         public static void Start()
         {
             if (!_IsRunning)
@@ -54,15 +71,16 @@ public static void Start()
                     _prevTimeApp = DateTime.Now;
 
                     appQueue = new AsyncCollection<object>();
-                   
 
+                    //This needs to run on UI thread context
+                    //So use task factory with the shared UI message pump thread
                     Task.Factory.StartNew(() => { }).ContinueWith(x =>
-                      {
-                          WindowHook.WindowCreated += new GeneralShellHookEventHandler(WindowCreated);
-                          WindowHook.WindowDestroyed += new GeneralShellHookEventHandler(WindowDestroyed);
-                          WindowHook.WindowActivated += new GeneralShellHookEventHandler(WindowActivated);
+                    {
+                        WindowHook.WindowCreated += new GeneralShellHookEventHandler(WindowCreated);
+                        WindowHook.WindowDestroyed += new GeneralShellHookEventHandler(WindowDestroyed);
+                        WindowHook.WindowActivated += new GeneralShellHookEventHandler(WindowActivated);
 
-                      }, SharedMessagePump.GetTaskScheduler());
+                    }, SharedMessagePump.GetTaskScheduler());
 
                     _lastEventWasLaunched = false;
                     _lastHwndLaunched = IntPtr.Zero;
@@ -72,6 +90,10 @@ public static void Start()
                 }
 
         }
+
+        /// <summary>
+        /// Quit watching
+        /// </summary>
         public static void Stop()
         {
             if (_IsRunning)
@@ -86,19 +108,44 @@ public static void Stop()
                 }
 
         }
+
+        /// <summary>
+        /// A windows was created on desktop
+        /// </summary>
+        /// <param name="shellObject"></param>
+        /// <param name="hWnd"></param>
         private static void WindowCreated(ShellHook shellObject, IntPtr hWnd)
         {
             appQueue.Add(new WindowData() { HWnd = hWnd, EventType = 0 });
         }
+
+        /// <summary>
+        /// An existing desktop window was destroyed
+        /// </summary>
+        /// <param name="shellObject"></param>
+        /// <param name="hWnd"></param>
         private static void WindowDestroyed(ShellHook shellObject, IntPtr hWnd)
         {
             appQueue.Add(new WindowData() { HWnd = hWnd, EventType = 2 });
         }
+
+        /// <summary>
+        /// A windows was brought to foreground
+        /// </summary>
+        /// <param name="shellObject"></param>
+        /// <param name="hWnd"></param>
         private static void WindowActivated(ShellHook shellObject, IntPtr hWnd)
         {
             appQueue.Add(new WindowData() { HWnd = hWnd, EventType = 1 });
         }
-        // This is the method to run when the timer is raised. 
+
+        /// <summary>
+        /// This is used to avoid blocking low level hooks
+        /// Otherwise if user takes long time to return the message
+        /// OS will unsubscribe the hook
+        /// Producer-consumer
+        /// </summary>
+        /// <returns></returns>
         private static async Task AppConsumer()
         {
             while (_IsRunning)
@@ -123,7 +170,16 @@ private static async Task AppConsumer()
 
             }
         }
+
+        /// <summary>
+        /// A handle to keep track of last window launched
+        /// </summary>
         private static IntPtr _lastHwndLaunched;
+
+        /// <summary>
+        /// A window got created
+        /// </summary>
+        /// <param name="wnd"></param>
         private static void WindowCreated(WindowData wnd)
         {
 
@@ -135,6 +191,11 @@ private static void WindowCreated(WindowData wnd)
 
         }
 
+        /// <summary>
+        /// invoke user call back
+        /// </summary>
+        /// <param name="wnd"></param>
+        /// <param name="appEvent"></param>
         private static void ApplicationStatus(WindowData wnd, ApplicationEvents appEvent)
         {
             var timeStamp = DateTime.Now;
@@ -143,13 +204,13 @@ private static void ApplicationStatus(WindowData wnd, ApplicationEvents appEvent
             wnd.AppPath = appEvent == ApplicationEvents.Closed ? wnd.AppPath : WindowHelper.GetAppPath(wnd.HWnd);
             wnd.AppName = appEvent == ApplicationEvents.Closed ? wnd.AppName : WindowHelper.GetAppDescription(wnd.AppPath);
 
-            EventHandler<ApplicationEventArgs> handler = OnApplicationWindowChange;
-            if (handler != null)
-            {
-                handler(null, new ApplicationEventArgs() { ApplicationData = wnd, Event = appEvent });
-            }
+            OnApplicationWindowChange?.Invoke(null, new ApplicationEventArgs() { ApplicationData = wnd, Event = appEvent });
         }
 
+        /// <summary>
+        /// Remove handle from active window collection
+        /// </summary>
+        /// <param name="wnd"></param>
         private static void WindowDestroyed(WindowData wnd)
         {
 
@@ -160,6 +221,10 @@ private static void WindowDestroyed(WindowData wnd)
             }
             _lastEventWasLaunched = false;
         }
+
+        /// <summary>
+        /// Add window handle to active windows collection
+        /// </summary>
         private static bool _lastEventWasLaunched;
         private static void WindowActivated(WindowData wnd)
         {

EventHook/ClipboardWatcher.cs

@@ -6,6 +6,9 @@
 
 namespace EventHook
 {
+    /// <summary>
+    /// Type of clipboard content
+    /// </summary>
     public enum ClipboardContentTypes
     {
         PlainText = 0,
@@ -15,12 +18,19 @@ public enum ClipboardContentTypes
         UnicodeText = 4
     }
 
+    /// <summary>
+    /// An argument send to user
+    /// </summary>
     public class ClipboardEventArgs : EventArgs
     {
         public object Data { get; set; }
         public ClipboardContentTypes DataFormat { get; set; }
     }
 
+    /// <summary>
+    /// Wraps around clipboardHook
+    /// Uses a producer-consumer pattern to improve performance and to avoid operating system forcing unhook on delayed user callbacks
+    /// </summary>
     public class ClipboardWatcher
     {
         /*Clip board monitor*/
@@ -32,6 +42,9 @@ public class ClipboardWatcher
 
         public static event EventHandler<ClipboardEventArgs> OnClipboardModified;
 
+        /// <summary>
+        /// Start watching
+        /// </summary>
         public static void Start()
         {
             if (!_IsRunning)
@@ -41,7 +54,7 @@ public static void Start()
                     {
                         _clipQueue = new AsyncCollection<object>();
 
-
+                        //Low level hooks need to be run in the context of a UI thread
                         Task.Factory.StartNew(() => { }).ContinueWith(x =>
                         {
                             _clip = new ClipBoardHook();
@@ -66,6 +79,10 @@ public static void Start()
                 }
 
         }
+
+        /// <summary>
+        /// Stop watching
+        /// </summary>
         public static void Stop()
         {
             if (_IsRunning)
@@ -89,11 +106,21 @@ public static void Stop()
                 }
 
         }
+
+        /// <summary>
+        /// Add event to producer queue
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
         private static void ClipboardHandler(object sender, EventArgs e)
         {
             _clipQueue.Add(sender);
         }
 
+        /// <summary>
+        /// Consume event from producer queue asynchronously
+        /// </summary>
+        /// <returns></returns>
         private static async Task ClipConsumerAsync()
         {
             while (_IsRunning)
@@ -103,11 +130,14 @@ private static async Task ClipConsumerAsync()
 
                 ClipboardHandler(item);
 
-
             }
 
         }
 
+        /// <summary>
+        /// Actuall handler to invoke user call backs
+        /// </summary>
+        /// <param name="sender"></param>
         private static void ClipboardHandler(object sender)
         {
 
@@ -164,11 +194,7 @@ private static void ClipboardHandler(object sender)
 
             if (!validDataType) return;
 
-            EventHandler<ClipboardEventArgs> handler = OnClipboardModified;
-            if (handler != null)
-            {
-                handler(null, new ClipboardEventArgs() { Data = data, DataFormat = format });
-            }
+            OnClipboardModified?.Invoke(null, new ClipboardEventArgs() { Data = data, DataFormat = format });
 
         }
     }

EventHook/Helpers/WindowHelper.cs

@@ -5,8 +5,15 @@
 
 namespace EventHook.Helpers
 {
+    /// <summary>
+    /// A helper class to get window names/handles etc
+    /// </summary>
     internal class WindowHelper
     {
+        /// <summary>
+        /// Get the handle of current acitive window on screen if any
+        /// </summary>
+        /// <returns></returns>
         internal static IntPtr GetActiveWindowHandle()
         {
             try
@@ -20,6 +27,11 @@ internal static IntPtr GetActiveWindowHandle()
             return IntPtr.Zero;
         }
 
+        /// <summary>
+        /// The the application exe path of this window
+        /// </summary>
+        /// <param name="hWnd">window handle</param>
+        /// <returns></returns>
         internal static string GetAppPath(IntPtr hWnd)
         {
             if (hWnd == IntPtr.Zero) return null;
@@ -35,7 +47,11 @@ internal static string GetAppPath(IntPtr hWnd)
                 return null;
             }
         }
-
+        /// <summary>
+        /// Get the title text of this window
+        /// </summary>
+        /// <param name="hWnd">widow handle</param>
+        /// <returns></returns>
         internal static string GetWindowText(IntPtr hWnd)
         {
             try
@@ -51,6 +67,11 @@ internal static string GetWindowText(IntPtr hWnd)
             }
         }
 
+        /// <summary>
+        /// Get the application description file attribute from path of an executable file
+        /// </summary>
+        /// <param name="appPath"></param>
+        /// <returns></returns>
         internal static string GetAppDescription(string appPath)
         {
             if (appPath == null) return null;