|
using System;
using System.Windows.Forms;
namespace Gma.UserActivityMonitor {
/// <summary>
/// This class monitors all mouse activities globally (also outside of the application)
/// and provides appropriate events.
/// </summary>
public static partial class HookManager
{
//################################################################
#region Mouse events
private static event MouseEventHandler s_MouseMove;
/// <summary>
/// Occurs when the mouse pointer is moved.
/// </summary>
public static event MouseEventHandler MouseMove
{
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseMove += value;
}
remove
{
s_MouseMove -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
private static event EventHandler<MouseEventExtArgs> s_MouseMoveExt;
/// <summary>
/// Occurs when the mouse pointer is moved.
/// </summary>
/// <remarks>
/// This event provides extended arguments of type <see cref="MouseEventArgs"/> enabling you to
/// supress further processing of mouse movement in other applications.
/// </remarks>
public static event EventHandler<MouseEventExtArgs> MouseMoveExt
{
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseMoveExt += value;
}
remove
{
s_MouseMoveExt -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
private static event MouseEventHandler s_MouseClick;
/// <summary>
/// Occurs when a click was performed by the mouse.
/// </summary>
public static event MouseEventHandler MouseClick
{
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseClick += value;
}
remove
{
s_MouseClick -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
private static event EventHandler<MouseEventExtArgs> s_MouseClickExt;
/// <summary>
/// Occurs when a click was performed by the mouse.
/// </summary>
/// <remarks>
/// This event provides extended arguments of type <see cref="MouseEventArgs"/> enabling you to
/// supress further processing of mouse click in other applications.
/// </remarks>
public static event EventHandler<MouseEventExtArgs> MouseClickExt
{
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseClickExt += value;
}
remove
{
s_MouseClickExt -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
private static event MouseEventHandler s_MouseDown;
/// <summary>
/// Occurs when the mouse a mouse button is pressed.
/// </summary>
public static event MouseEventHandler MouseDown
{
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseDown += value;
}
remove
{
s_MouseDown -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
private static event MouseEventHandler s_MouseUp;
/// <summary>
/// Occurs when a mouse button is released.
/// </summary>
public static event MouseEventHandler MouseUp
{
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseUp += value;
}
remove
{
s_MouseUp -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
private static event MouseEventHandler s_MouseWheel;
/// <summary>
/// Occurs when the mouse wheel moves.
/// </summary>
public static event MouseEventHandler MouseWheel
{
add
{
EnsureSubscribedToGlobalMouseEvents();
s_MouseWheel += value;
}
remove
{
s_MouseWheel -= value;
TryUnsubscribeFromGlobalMouseEvents();
}
}
private static event MouseEventHandler s_MouseDoubleClick;
//The double click event will not be provided directly from hook.
//To fire the double click event wee need to monitor mouse up event and when it occures
//Two times during the time interval which is defined in Windows as a doble click time
//we fire this event.
/// <summary>
/// Occurs when a double clicked was performed by the mouse.
/// </summary>
public static event MouseEventHandler MouseDoubleClick
{
add
{
EnsureSubscribedToGlobalMouseEvents();
if (s_MouseDoubleClick == null)
{
//We create a timer to monitor interval between two clicks
s_DoubleClickTimer = new Timer
{
//This interval will be set to the value we retrive from windows. This is a windows setting from contro planel.
Interval = GetDoubleClickTime(),
//We do not start timer yet. It will be start when the click occures.
Enabled = false
};
//We define the callback function for the timer
s_DoubleClickTimer.Tick += DoubleClickTimeElapsed;
//We start to monitor mouse up event.
MouseUp += OnMouseUp;
}
s_MouseDoubleClick += value;
}
remove
{
if (s_MouseDoubleClick != null)
{
s_MouseDoubleClick -= value;
if (s_MouseDoubleClick == null)
{
//Stop monitoring mouse up
MouseUp -= OnMouseUp;
//Dispose the timer
s_DoubleClickTimer.Tick -= DoubleClickTimeElapsed;
s_DoubleClickTimer = null;
}
}
TryUnsubscribeFromGlobalMouseEvents();
}
}
//This field remembers mouse button pressed because in addition to the short interval it must be also the same button.
private static MouseButtons s_PrevClickedButton;
//The timer to monitor time interval between two clicks.
private static Timer s_DoubleClickTimer;
private static void DoubleClickTimeElapsed(object sender, EventArgs e)
{
//Timer is alapsed and no second click ocuured
s_DoubleClickTimer.Enabled = false;
s_PrevClickedButton = MouseButtons.None;
}
/// <summary>
/// This method is designed to monitor mouse clicks in order to fire a double click event if interval between
/// clicks was short enaugh.
/// </summary>
/// <param name="sender">Is always null</param>
/// <param name="e">Some information about click heppened.</param>
private static void OnMouseUp(object sender, MouseEventArgs e)
{
//This should not heppen
if (e.Clicks < 1) { return;}
//If the secon click heppened on the same button
if (e.Button.Equals(s_PrevClickedButton))
{
if (s_MouseDoubleClick!=null)
{
//Fire double click
s_MouseDoubleClick.Invoke(null, e);
}
//Stop timer
s_DoubleClickTimer.Enabled = false;
s_PrevClickedButton = MouseButtons.None;
}
else
{
//If it was the firts click start the timer
s_DoubleClickTimer.Enabled = true;
s_PrevClickedButton = e.Button;
}
}
#endregion
//################################################################
#region Keyboard events
private static event KeyPressEventHandler s_KeyPress;
/// <summary>
/// Occurs when a key is pressed.
/// </summary>
/// <remarks>
/// Key events occur in the following order:
/// <list type="number">
/// <item>KeyDown</item>
/// <item>KeyPress</item>
/// <item>KeyUp</item>
/// </list>
///The KeyPress event is not raised by noncharacter keys; however, the noncharacter keys do raise the KeyDown and KeyUp events.
///Use the KeyChar property to sample keystrokes at run time and to consume or modify a subset of common keystrokes.
///To handle keyboard events only in your application and not enable other applications to receive keyboard events,
/// set the KeyPressEventArgs.Handled property in your form's KeyPress event-handling method to <b>true</b>.
/// </remarks>
public static event KeyPressEventHandler KeyPress
{
add
{
EnsureSubscribedToGlobalKeyboardEvents();
s_KeyPress += value;
}
remove
{
s_KeyPress -= value;
TryUnsubscribeFromGlobalKeyboardEvents();
}
}
private static event KeyEventHandler s_KeyUp;
/// <summary>
/// Occurs when a key is released.
/// </summary>
public static event KeyEventHandler KeyUp
{
add
{
EnsureSubscribedToGlobalKeyboardEvents();
s_KeyUp += value;
}
remove
{
s_KeyUp -= value;
TryUnsubscribeFromGlobalKeyboardEvents();
}
}
private static event KeyEventHandler s_KeyDown;
/// <summary>
/// Occurs when a key is preseed.
/// </summary>
public static event KeyEventHandler KeyDown
{
add
{
EnsureSubscribedToGlobalKeyboardEvents();
s_KeyDown += value;
}
remove
{
s_KeyDown -= value;
TryUnsubscribeFromGlobalKeyboardEvents();
}
}
#endregion
}
}
|
By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.
If a file you wish to view isn't highlighted, and is a text file (not binary), please
let us know and we'll add colourisation support for it.