private void Subscribe(IKeyboardMouseEvents events)
{
m_Events = events;
m_Events.KeyDown += OnKeyDown;
m_Events.KeyUp += OnKeyUp;
m_Events.KeyPress += HookManager_KeyPress;
m_Events.MouseUp += OnMouseUp;
m_Events.MouseClick += OnMouseClick;
m_Events.MouseDoubleClick += OnMouseDoubleClick;
m_Events.MouseMove += HookManager_MouseMove;
m_Events.MouseDragStarted += OnMouseDragStarted;
m_Events.MouseDragFinished += OnMouseDragFinished;
if (checkBoxSupressMouseWheel.Checked)
m_Events.MouseWheelExt += HookManager_MouseWheelExt;
else
m_Events.MouseWheel += HookManager_MouseWheel;
if (checkBoxSuppressMouse.Checked)
m_Events.MouseDownExt += HookManager_Supress;
else
m_Events.MouseDown += OnMouseDown;
}
public void Initialize()
{
_globalHook = Hook.GlobalEvents();
_globalHook.KeyDown += KeyDown;
_globalHook.KeyPress += KeyPress;
}
private void button1_Click(object sender, EventArgs e)
{
if (IsActive)
{
globalKeyboardHook.KeyDown -= GlobalHook_KeyDown;
globalKeyboardHook.Dispose();
LogitechGSDK.LogiLedStopEffects();
LogitechGSDK.LogiLedRestoreLighting();
(sender as Button).Text = "Start";
IsActive = false;
}
else
{
globalKeyboardHook = Hook.GlobalEvents();
globalKeyboardHook.KeyDown += GlobalHook_KeyDown;
(sender as Button).Text = "Stop";
LogitechGSDK.LogiLedInit();
Thread.Sleep(100); //init needs some time... this shouldn't block the UI-thread, but it's the best solution for now...
LogitechGSDK.LogiLedSaveCurrentLighting();
ActivateKey();
IsActive = true;
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
_globalHook = Hook.GlobalEvents();
_globalHook.KeyDown += GlobalHookKeyDown;
_globalHook.KeyUp += GlobalHookKeyUp;
}
public MainWindow()
{
InitializeComponent();
//UI
tbSongName.DataContext = SuperSong;
tbArtist.DataContext = SuperSong;
//Timer
media.MediaEnded += Media_MediaEnded;
_timer = new DispatcherTimer
{
Interval = TimeSpan.FromSeconds(1)
};
_timer.Tick += _timer_Tick;
//Slider
TimeSlider.AddHandler(MouseLeftButtonUpEvent, new MouseButtonEventHandler(TimeSlider_MouseLeftButtonUp), true);
TimeSlider.ValueChanged += TimeSlider_ValueChanged;
VolumeSlider.ValueChanged += VolumeSlider_ValueChanged;
VolumeSlider.AddHandler(MouseLeftButtonUpEvent, new MouseButtonEventHandler(VolumnSlider_MouseLeftButtonUp), true);
//Playlist
lvNowPlaying.ItemsSource = playlist;
lvCustomPlaylist.ItemsSource = customplaylist;
//Tooltip
btnRepeatMode.DataContext = playmode;
btnPlayRandomMode.DataContext = isPlayingRandomly;
//Hook
_hook = Hook.GlobalEvents();
_hook.KeyUp += _hook_KeyUp;
}
/// <summary>
/// Initializes a new RLSpectrum instance
/// </summary>
/// <param name="game"></param>
/// <param name="provider"></param>
/// <param name="fftSize"></param>
public RLSpectrum(MainGame game, SpectrumProvider provider, FftSize fftSize) : base(fftSize)
{
this.game = game;
SpectrumProvider = provider;
UseAverage = true;
Resolution = MatrixResolution + LowCut + HighCut;
IsXLogScale = true;
ScalingStrategy = ScalingStrategy.Decibel;
effect = new BasicEffect(game.GraphicsDevice)
{
DiffuseColor = RetroPurple.ToVector3()
};
random = new Random();
matrix = new RLMatrix(game, MatrixNumEntries, MatrixResolution);
linePlot = new RLLinePlot(MatrixResolution, LineCache, RetroPurple);
carTexture = game.Content.Load <Texture2D>("Images/Octane");
messageTexture = game.Content.Load <Texture2D>("Images/Message");
spriteFont = game.Content.Load <SpriteFont>("Fonts/Lazer84");
car = new RLCar(carTexture, RetroBlue, random);
countdown = new RLCountdown(spriteFont, RetroRed);
countdown.Alarm += CountdownAlarm;
constrainedPoints = new SpectrumPointData[MatrixResolution];
globalHook = Hook.GlobalEvents();
globalHook.KeyDown += KeyDown;
}
public void Subscribe()
{
// Note: for the application hook, use the Hook.AppEvents() instead
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.MouseDownExt += GlobalHookMouseDownExt;
m_GlobalHook.MouseUpExt += GlobalHookMouseUpExt;
}
public Form1()
{
InitializeComponent();
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.MouseDownExt += GlobalHookMouseDownExt;
env_path = Environment.GetFolderPath(Environment.SpecialFolder.MyVideos);
}
private void Subscribe(IKeyboardMouseEvents events)
{
m_Events = events;
//m_Events.KeyDown += OnKeyDown;
//m_Events.KeyUp += OnKeyUp;
//m_Events.KeyPress += HookManager_KeyPress;
//m_Events.MouseUp += OnMouseUp;
//m_Events.MouseClick += OnMouseClick;
//m_Events.MouseDoubleClick += OnMouseDoubleClick;
m_Events.MouseMove += HookManager_MouseMove;
//m_Events.MouseDragStarted += OnMouseDragStarted;
//m_Events.MouseDragFinished += OnMouseDragFinished;
//if (checkBoxSupressMouseWheel.Checked)
//m_Events.MouseWheelExt += HookManager_MouseWheelExt;
//else
//m_Events.MouseWheel += HookManager_MouseWheel;
//if (checkBoxSuppressMouse.Checked)
//m_Events.MouseDownExt += HookManager_Supress;
//else
//m_Events.MouseDown += OnMouseDown;
}
/// <summary>
/// Initializes a new instance of the <see cref="HookController"/> class.
/// </summary>
/// <param name="x">
/// Transparent SDL2Window top left corner X axis.
/// </param>
/// <param name="y">
/// Transparent SDL2Window top left corner Y axis.
/// </param>
public HookController(int x, int y)
{
this.windowX = x;
this.windowY = y;
this.enable = true;
this.myHook = Hook.GlobalEvents();
}
public Keyhole(Keys overlayKey)
{
m_overlayKey = overlayKey;
m_Ts = new ThreadStart(DrawLoop);
m_DrawThread = new Thread(m_Ts);
// setup eye tracker
m_EyeTracker = EyeTrackingOperations.FindAllEyeTrackers().FirstOrDefault();
m_EyeTracker.GazeDataReceived += GazeDataReceived;
// init gaze points
ScreenGaze = new ScreenGaze();
GazeTargets = new List <GazeTarget>();
Screen = System.Windows.Forms.Screen.PrimaryScreen.Bounds;
window = new Form1(this);
m_Active = false;
// keyboard / mouse
m_Events = Hook.GlobalEvents();
m_Events.KeyDown += OnKeyDown;
//m_Events.KeyUp += OnKeyUp;
//m_Events.KeyPress += HookManager_KeyPress;
m_Events.MouseMove += OnMouseMove;
m_DrawThread.Start();
}
private void Unsubscribe()
{
if (m_Events == null)
{
return;
}
//m_Events.KeyDown -= OnKeyDown;
//m_Events.KeyUp -= OnKeyUp;
//m_Events.KeyPress -= HookManager_KeyPress;
//m_Events.MouseUp -= OnMouseUp;
//m_Events.MouseClick -= OnMouseClick;
//m_Events.MouseDoubleClick -= OnMouseDoubleClick;
m_Events.MouseMove -= HookManager_MouseMove;
//m_Events.MouseDragStarted -= OnMouseDragStarted;
//m_Events.MouseDragFinished -= OnMouseDragFinished;
//if (checkBoxSupressMouseWheel.Checked)
//m_Events.MouseWheelExt -= HookManager_MouseWheelExt;
//else
//m_Events.MouseWheel -= HookManager_MouseWheel;
//if (checkBoxSuppressMouse.Checked)
//m_Events.MouseDownExt -= HookManager_Supress;
//else
//m_Events.MouseDown -= OnMouseDown;
m_Events.Dispose();
m_Events = null;
}
public void Subscribe()
{
// Note: for the application hook, use the Hook.AppEvents() instead
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.KeyDown += GlobalHookKeyDown;
}
public Form1()
{
InitializeComponent();
this.Opacity = 0;
inputSim = new InputSimulator();
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.KeyDown += M_GlobalHook_KeyDown;
m_GlobalHook.KeyUp += M_GlobalHook_KeyUp;
lblStatus.Location = new Point(lblStatus.Location.X, lblStatus.Location.Y + 40);
pbStatus.Location = new Point(pbStatus.Location.X, pbStatus.Location.Y + 40);
btnExport.Location = new Point(btnExport.Location.X, pbStatus.Location.Y - 5);
btnImport.Location = new Point(btnImport.Location.X, pbStatus.Location.Y - 5);
tbLog.Size = new Size(tbLog.Size.Width, tbLog.Size.Height + 30);
Directory.CreateDirectory(Path.GetDirectoryName(Database.databaseFile));
AppDomain.CurrentDomain.SetData("DataDirectory", Database.databaseFile);
Database.CreateDatabaseIfNotExist();
kc = new KeysConverter();
StartStopRecording = (Keys)kc.ConvertFromString(Database.HotKeyStartStopRecording);
PlaybackRecording = (Keys)kc.ConvertFromString(Database.HotKeyPlaybackRecording);
SetControlValues();
random = new Random();
tbLog.AppendText(" == Initialized MousePlayBack V" + IO.ApplicationVersion + " ==\r\n");
tmrFadeIn.Start();
}
protected override void OnSourceInitialized(EventArgs e)
{
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.MouseClick += m_GlobalHook_MouseClick;
base.OnSourceInitialized(e);
}
public Task OnAfterInit()
{
hook = Hook.GlobalEvents();
hook.KeyDown += Hook_KeyDown;
return(Task.CompletedTask);
}
private void SubscribeHooks()
{
MouseKey_Hook = Hook.GlobalEvents();
MouseKey_Hook.KeyDown += MouseKey_Hook_KeyDown;
MouseKey_Hook.MouseClick += MouseKey_Hook_MouseClick;
}
public Windows10RegionSelector(IKeyboardMouseEvents kmEvents)
{
this.kmEvents = kmEvents;
this.kmEvents.MouseDown += StartDragRegion;
this.kmEvents.MouseUp += StopShooting;
this.kmEvents.MouseMoveExt += MouseMove;
shield = new Form
{
FormBorderStyle = FormBorderStyle.None,
Opacity = 0.01,
MinimumSize = new Size(1, 1),
Size = new Size(CursorPadding * 2, CursorPadding * 2),
ShowInTaskbar = false,
Cursor = Cursors.Cross
};
regionSelector = new Form
{
BackColor = Color.White,
FormBorderStyle = FormBorderStyle.None,
TopMost = true,
Opacity = 0.5,
MinimumSize = new Size(1, 1),
Size = new Size(1, 1),
ShowInTaskbar = false,
};
}
public MouseRecorder()
{
this.m_Hook = Hook.GlobalEvents();
m_Hook.MouseMoveExt += M_Hook_MouseMoveExt;
m_Hook.MouseDownExt += M_Hook_MouseDownExt;
m_Hook.MouseDown += M_Hook_MouseDown;
}
private static void Subscribe(IKeyboardMouseEvents events)
{
m_Events = events;
m_Events.KeyDown += OnKeyDown;
m_Events.MouseDownExt += HookManager_Supress;
}
/// <summary>
///
/// </summary>
/// <param name="events"></param>
private void Subscribe(IKeyboardMouseEvents events)
{
m_events = events;
m_events.KeyDown += OnKeyDown;
m_events.KeyUp += OnKeyUp;
m_events.KeyPress += OnKeyPress;
}
public void Subscribe()
{
// Note: for the application hook, use the Hook.AppEvents() instead
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.MouseDownExt += GlobalHookMouseDownExt;
//m_GlobalHook.KeyPress += GlobalHookKeyPress;
}
private void SubscribeMouseEvents(IKeyboardMouseEvents events)
{
_keyboardMouseEvents = events;
_keyboardMouseEvents.MouseMove += OnMouseMove;
_keyboardMouseEvents.KeyDown += OnKeyDown;
_keyboardMouseEvents.KeyUp += OnKeyUp;
}
/// <summary>
/// Creates a new instance of <see cref="MouseKeyHook"/>.
/// </summary>
public MouseKeyHook(MouseClickSettings MouseClickSettings,
KeystrokesSettings KeystrokesSettings,
KeymapViewModel Keymap,
string FileName,
Func <TimeSpan> Elapsed)
{
_mouseClickSettings = MouseClickSettings;
_keystrokesSettings = KeystrokesSettings;
_keymap = Keymap;
_hook = Hook.GlobalEvents();
_hook.MouseDown += (S, E) =>
{
_mouseClicked = true;
_mouseButtons = E.Button;
};
_hook.MouseUp += (S, E) => _mouseClicked = false;
if (KeystrokesSettings.SeparateTextFile)
{
_textWriter = InitKeysToTextFile(FileName, Elapsed);
}
else
{
_records = new KeyRecords(KeystrokesSettings.HistoryCount);
_hook.KeyDown += OnKeyDown;
_hook.KeyUp += OnKeyUp;
}
}
private void Window_Loaded(object sender, RoutedEventArgs e)
{
playList.ItemsSource = _playlist;
try
{
StreamReader sr = new StreamReader("lastPlaying");
int lastSongIndex = int.Parse(sr.ReadLine());
if (lastSongIndex != -1)
{
loadSongList("lastlist");
isSelected = true;
index = lastSongIndex;
PlaySelectedIndex(index);
}
sr.Close();
}
catch (Exception ex)
{
}
try{
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.KeyUp += KeyUp_hook;
}
catch (Exception ex)
{
MessageBoxError("Một số tập tin bị thiếu. Vui lòng cài đặt lại chương trình");
}
}
private void StartWndProcHandler(IntPtr hwnd)
{
_rawInput = new RawPresentationInput(hwnd, RawInputCaptureMode.ForegroundAndBackground);
_rawInput.KeyPressed += OnKeyPressed;
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.MouseDownExt += (sender, args) =>
{
if (args.Button == MouseButtons.Right)
{
if (Application.Current.MainWindow is Information mainWindow)
{
System.Windows.Forms.Cursor.Position = new System.Drawing.Point((int)mainWindow.Left + 4, (int)mainWindow.Top + 4);
//mainWindow.Close();
}
}
};
m_GlobalHook.MouseUp += (sender, args) =>
{
if (args.Button == MouseButtons.Right)
{
if (Application.Current.MainWindow is Information mainWindow)
{
//System.Windows.Forms.Cursor.Position = new System.Drawing.Point((int)mainWindow.Left + 4, (int)mainWindow.Top + 4);
mainWindow.Close();
}
}
};
//DeviceCount = _rawInput.NumberOfKeyboards;
}
private void Unsubscribe()
{
if (m_Events == null)
{
return;
}
m_Events.KeyDown -= OnKeyDown;
m_Events.KeyUp -= OnKeyUp;
m_Events.KeyPress -= HookManager_KeyPress;
m_Events.MouseUp -= OnMouseUp;
m_Events.MouseClick -= OnMouseClick;
m_Events.MouseDoubleClick -= OnMouseDoubleClick;
m_Events.MouseMove -= HookManager_MouseMove;
m_Events.MouseDragStarted -= OnMouseDragStarted;
m_Events.MouseDragFinished -= OnMouseDragFinished;
m_Events.MouseWheel -= HookManager_MouseWheel;
m_Events.MouseDown -= OnMouseDown;
m_Events.Dispose();
m_Events = null;
}
public MainWindow()
{
InitializeComponent();
// This ensures that the window is always on top, doesn't always work but should be good enough
this.Topmost = true;
// Initial opacity
sliderMenu.Value = 100;
// Hooks to make the "M" key a keybind to toggle map
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.KeyDown += GlobalHookKeyDown;
opacity = sliderMenu.Value;
this.Background = new SolidColorBrush(Colors.Black)
{
Opacity = 0
};
this.Opacity = opacity * 0.01;
this.BorderBrush = new SolidColorBrush(Colors.Black)
{
Opacity = 0
};
transparentBackground = true;
}
public MouseListener()
{
m_GlobalHook = Hook.GlobalEvents();
//create event handlers
m_GlobalHook.MouseDownExt += GlobalHookMouseDownExt;
m_GlobalHook.MouseMoveExt += GlobalHookMouseMove;
}
private void SetUpHotKeys()
{
_globalHook = Hook.GlobalEvents();
_globalHook.MouseDown += (o, e) =>
{
if (e.X < Left || e.X > Left + Width || e.Y < Top || e.Y > Top + Height)
{
HideMainWindow();
}
};
_globalHook.OnCombination(new Dictionary <Combination, Action>()
{
{
Combination.FromString("Pause"), () =>
{
CopyFromActiveProgram();
ShowMainWindow();
}
},
{
Combination.FromString("Escape"), HideMainWindow
}
});
}
// Constructors
// ============
/// <exception cref="System.Runtime.InteropServices.ExternalException"></exception>
/// <exception cref="System.Threading.ThreadStateException"></exception>
/// <exception cref="InvalidOperationException"></exception>
public MainWindow()
{
closeLock = true;
InitializeComponent();
foreach (char letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890")
{
cbKeys.Items.Add(new ComboBoxItem()
{
Content = letter
});
}
foreach (MockType mockType in Enum.GetValues(typeof(MockType)))
{
cbCase.Items.Add(new ComboBoxItem()
{
Content = mockType.ReadableText(),
Tag = mockType
});
}
IconLeftClick = new Command(DoIconLeftClick);
keyboardMouseEvents = Hook.GlobalEvents();
keyboardMouseEvents.KeyDown += KeyboardMouseEvents_KeyDown;
ImportSavedData();
}
/// <summary>
/// Creates a new instance of <see cref="MouseKeyHook"/>.
/// </summary>
public MouseKeyHook(MouseClickSettings mouseClickSettings,
KeystrokesSettings keystrokesSettings,
KeymapViewModel keymap,
string fileName,
Func <TimeSpan> elapsed)
{
_mouseClickSettings = mouseClickSettings;
_keystrokesSettings = keystrokesSettings;
_keymap = keymap;
_hook = Hook.GlobalEvents();
_hook.MouseDown += (sender, e) =>
{
_mouseClicked = true;
_mouseButtons = e.Button;
};
_hook.MouseUp += (sender, e) => _mouseClicked = false;
if (keystrokesSettings.SeparateTextFile)
{
_textWriter = InitKeysToTextFile(fileName, elapsed);
}
else
{
_records = new KeyRecords(keystrokesSettings.HistoryCount);
_hook.KeyDown += OnKeyDown;
_hook.KeyUp += OnKeyUp;
}
}
public static void Initialize()
{
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.KeyPress += BlockEnterKeyPress;
m_GlobalHook.KeyDown += BlockEnterKeyDown;
m_GlobalHook.KeyUp += BlockEnterKeyUp;
}
private void SubscribeWindowsHookEvents()
{
_mEvents = Hook.GlobalEvents();
_mEvents.MouseWheel += OnMouseWheelMove;
_mEvents.KeyDown += OnKeyDown;
_mEvents.KeyUp += OnKeyUp;
}
private static void Subscribe(IKeyboardMouseEvents events)
{
m_Events = events;
m_Events.KeyDown += OnKeyDown;
m_Events.KeyUp += OnKeyUp;
m_Events.KeyPress += HookManager_KeyPress;
}
private void M_Hook_KeyPress(object sender, System.Windows.Forms.KeyPressEventArgs e)
{
if (null != m_Hook)
{
m_Hook.KeyPress -= M_Hook_KeyPress;
m_Hook = null;
}
}
internal static void RegisterEvents()
{
m_events = Hook.GlobalEvents();
m_events.MouseDownExt += M_events_MouseDownExt;
m_events.MouseUpExt += M_events_MouseDownExt;
m_events.MouseMoveExt += M_events_MouseMove;
m_events.MouseClick += M_events_MouseClick;
m_events.MouseWheelExt += M_events_MouseDownExt;
m_events.MouseWheelExt += M_events_MouseDownExt;
}
public MainWindow()
{
InitializeComponent();
Load();
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.KeyDown += GlobalHook_KeyDown;
_timer.Tick += timer_Tick;
_timer.Start();
}
private void Dispose(bool disposing)
{
if (null != m_MoveAction)
{
m_MoveAction = null;
}
if (null != m_Hook)
{
m_Hook.MouseMoveExt -= M_Hook_MouseMoveExt;
m_Hook.MouseDownExt -= M_Hook_MouseDownExt;
m_Hook.MouseDown -= M_Hook_MouseDown;
m_Hook = null;
}
}
/// <summary>
/// Subscribes the local mouse and keyboard hooks.
/// </summary>
private void SubscribeEvents()
{
if (PlatformHelper.RunningOnMono) // Mono/Linux
{
this.KeyDown += OnKeyDown;
this.KeyUp += OnKeyUp;
}
else // Windows
{
_keyboardHook = Hook.GlobalEvents();
_keyboardHook.KeyDown += OnKeyDown;
_keyboardHook.KeyUp += OnKeyUp;
_mouseHook = Hook.AppEvents();
_mouseHook.MouseWheel += OnMouseWheelMove;
}
}
private void RegisterKeyHooks()
{
globalKeyMouseHook = Hook.GlobalEvents();
globalKeyMouseHook.MouseDownExt += (send, e) => {
if (!ApplicationIsActivated()) return;
switch (e.Button)
{
case MouseButtons.XButton1:
navigateBackBrowser();
break;
case MouseButtons.XButton2:
navigateForwardBrowser();
break;
}
};
globalKeyMouseHook.KeyUp += new KeyEventHandler(gkh_KeyUp);
FormClosed += (send, e) =>
{
globalKeyMouseHook.Dispose();
};
}
public override void Start()
{
// Register Save-To-Database Timer
if (_saveToDatabaseTimer != null)
Stop();
_saveToDatabaseTimer = new Timer();
_saveToDatabaseTimer.Interval = Settings.UserInputAggregationInterval.TotalMilliseconds;
_saveToDatabaseTimer.Elapsed += SaveToDatabaseTick;
_saveToDatabaseTimer.Start();
// Register Hooks for Mouse & Keyboard
_mEvents = Hook.GlobalEvents();
_mEvents.MouseWheel += MouseListener_MouseScrolling;
_mEvents.MouseClick += MouseListener_MouseClick;
_mEvents.MouseMoveExt += MouseListener_MouseMoveExt;
_mEvents.KeyDown += KeyboardListener_KeyDown;
// Set start timestamp for tracking
_tsStart = DateTime.Now;
IsRunning = true;
}
/// <summary>
/// Subscribes the specified events.
/// </summary>
/// <param name="events">The events.</param>
private void Subscribe(IKeyboardMouseEvents events)
{
_events = events;
_events.KeyDown += OnKeyDown;
_events.KeyUp += OnKeyUp;
_events.KeyPress += HookManager_KeyPress;
_events.MouseUp += OnMouseUp;
_events.MouseClick += OnMouseClick;
_events.MouseDoubleClick += OnMouseDoubleClick;
_events.MouseMove += HookManager_MouseMove;
_events.MouseWheelExt += HookManager_MouseWheelExt;
_events.MouseDownExt += HookManager_SupressMouse;
}
/// <summary>
/// Unsubscribes events.
/// </summary>
private void Unsubscribe()
{
if (_events == null)
{
return;
}
_events.KeyDown -= OnKeyDown;
_events.KeyUp -= OnKeyUp;
_events.KeyPress -= HookManager_KeyPress;
_events.MouseUp -= OnMouseUp;
_events.MouseClick -= OnMouseClick;
_events.MouseDoubleClick -= OnMouseDoubleClick;
_events.MouseMove -= HookManager_MouseMove;
_events.MouseWheelExt -= HookManager_MouseWheelExt;
_events.MouseDownExt -= HookManager_SupressMouse;
_events.Dispose();
_events = null;
}
public void Subscribe()
{
// Note: for the application hook, use the Hook.AppEvents() instead
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.KeyUp += GlobalHookKeyUp;
}
/// <summary>
/// Starts the inactivity detection algorithm
/// </summary>
private void InactivityDetector()
{
mouseHook = Hook.AppEvents();
mouseHook.MouseMove += IDetect; //enable this code for idle detection
timerIDetector.Start();
}
void Sub()
{
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.KeyUp += m_GlobalHook_KeyUp;
}
private void applyToggleListening()
{
if (currentOptions.toggleListening) {
try {
if (m_GlobalHook == null) {
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.KeyDown += GlobalHookKeyDown;
m_GlobalHook.KeyUp += GlobalHookKeyUp;
}
}
catch {
Console.WriteLine("Couldn't register key properly");
}
}
else {
try {
if (m_GlobalHook != null) {
m_GlobalHook.KeyDown -= GlobalHookKeyDown;
m_GlobalHook.KeyUp -= GlobalHookKeyUp;
m_GlobalHook.Dispose();
m_GlobalHook = null;
}
}
catch {
Console.WriteLine("Couldn't unregister key properly");
}
}
}
public static void Subscribe()
{
globalHookEvents = Hook.GlobalEvents();
globalHookEvents.KeyDown += GlobalHookKeyDownExt;
}
public override void Stop()
{
if (_saveToDatabaseTimer != null)
{
_saveToDatabaseTimer.Stop();
_saveToDatabaseTimer.Dispose();
_saveToDatabaseTimer = null;
}
//if (_mouseSnapshotTimer != null)
//{
// _mouseSnapshotTimer.Stop();
// _mouseSnapshotTimer.Dispose();
// _mouseSnapshotTimer = null;
//}
// unregister mouse & keyboard events
if (_mEvents != null)
{
_mEvents.MouseWheel -= MouseListener_MouseScrolling;
_mEvents.MouseClick -= MouseListener_MouseClick;
_mEvents.MouseMoveExt -= MouseListener_MouseMoveExt;
_mEvents.KeyDown -= KeyboardListener_KeyDown;
_mEvents.Dispose();
_mEvents = null;
}
IsRunning = false;
}
public void Initialize()
{
_globalHook = Hook.GlobalEvents();
_globalHook.MouseClick += MouseClick;
_globalHook.MouseDoubleClick += MouseDoubleClick;
}
public Form1()
{
InitializeComponent();
g_events = Hook.GlobalEvents();
}
public void Subscribe()
{
LogHelper.Debug(this, "Subscribing to the global hook");
// Note: for the application hook, use the Hook.AppEvents() instead
m_GlobalHook = Hook.GlobalEvents();
m_GlobalHook.KeyDown += GlobalHookKeyDown;
LogHelper.Debug(this, "Subscribed to the global hook");
}
private GetWindowController()
{
_mGlobalHook = Hook.GlobalEvents();
}
private void SubscribeWindowsHookEvents()
{
_mEvents = Hook.GlobalEvents();
_mEvents.MouseWheel += OnMouseWheelMove;
_mEvents.KeyDown += OnKeyDown;
_mEvents.KeyUp += OnKeyUp;
}
private void Unsubscribe()
{
if (m_Events == null) return;
m_Events.KeyDown -= OnKeyDown;
m_Events.KeyUp -= OnKeyUp;
m_Events.KeyPress -= HookManager_KeyPress;
m_Events.MouseUp -= OnMouseUp;
m_Events.MouseClick -= OnMouseClick;
m_Events.MouseDoubleClick -= OnMouseDoubleClick;
m_Events.MouseMove -= HookManager_MouseMove;
m_Events.MouseDragStarted -= OnMouseDragStarted;
m_Events.MouseDragFinished -= OnMouseDragFinished;
if (checkBoxSupressMouseWheel.Checked)
m_Events.MouseWheelExt -= HookManager_MouseWheelExt;
else
m_Events.MouseWheel -= HookManager_MouseWheel;
if (checkBoxSuppressMouse.Checked)
m_Events.MouseDownExt -= HookManager_Supress;
else
m_Events.MouseDown -= OnMouseDown;
m_Events.Dispose();
m_Events = null;
}
public KeyboardRecorder()
{
this.m_Hook = Hook.GlobalEvents();
m_Hook.KeyPress += M_Hook_KeyPress;
}
private void StartHooks()
{
var wih = new WindowInteropHelper(mainWindow);
hWndSource = HwndSource.FromHwnd(wih.Handle);
globalMouseHook = Hook.GlobalEvents();
var source = hWndSource;
if (source != null)
{
source.AddHook(WinProc); // start processing window messages
hWndNextViewer = Win32.SetClipboardViewer(source.Handle); // set this window as a viewer
}
}
private void Subscribe(IKeyboardMouseEvents events)
{
_mEvents = events;
_mEvents.KeyDown += OnKeyDown;
_mEvents.KeyUp += OnKeyUp;
_mEvents.KeyPress += OnKeyPress;
}
private void cmd_mouse_monitorMouse_Click(object sender, EventArgs e)
{
if (!mouseActionsSubscribed)
{
mouseHook = Hook.GlobalEvents();
mouseHook.MouseMoveExt += globalMouseMoveExt;
cmd_mouse_monitorMouse.Text = "Stop monitoring";
mouseActionsSubscribed = true;
}
else
{
mouseActionsSubscribed = false;
mouseHook.MouseMoveExt -= globalMouseMoveExt;
cmd_mouse_monitorMouse.Text = "Monitor desktop mouse";
mouseStartX = -1;
mouseStartY = -1;
}
}
