Yeah, that's where I found the code for the remote Control, but I think it's out of date for Vista. One of the posters here in a thread on the remote control pointed out in Toub's update vista app that this method wouldn't work - because of security I think, the ui just blocks it all (if I understood it?)
As I said I can't egt the reference to wndproc to be recognised, otherwise since all I wanted to do was recognise one key (i.e. the hash key) then it would have been sweet. But nothing is ever that simple.
Anyway, after investigating keyboard hooks and trying to find some simple code and failing, I've managed to hack Stephen's code to extract the stuff needed to display the basic keys.
Here it is: Please note folks that this is Stephen's code and really you should acknowledge that in any apps (is permission needed in commercial apps?)
using System;
using System.Timers;
using System.Collections;
using System.Collections.Generic;
using System.Threading;
using Microsoft.MediaCenter;
using Microsoft.MediaCenter.Hosting;
using Microsoft.MediaCenter.UI;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using System.Diagnostics;
using System.ComponentModel;
using System.IO;
using System.Runtime.ConstrainedExecution;
using System.Security;
using System.Security.Permissions;
using Microsoft.Win32.SafeHandles;
namespace VMCMusicList
{
public class VMCMusicList : IAddInModule, IAddInEntryPoint
{
private AddInHost _host;
private ManualResetEvent vmcWaitForExit;
private Process _ehshellProcess;
// Initialize (IAddInModule)
public void Initialize(Dictionary<string, object> appInfo, Dictionary<string, object> entryPointInfo)
{
}
// Uninitialize (IAddInModule)
public void Uninitialize()
{
}
// Launch (IAddInModule)
public void Launch(AddInHost host)
{
try
{
_host = host; //so that host is available globally in the code
using (vmcWaitForExit = new ManualResetEvent(false)) //Keep app alive till vmc exit
{
using (_ehshellProcess = GetEhShellProcess()) // Get the ehshell process
using (new KeyboardHook(_ehshellProcess.Id, hook_KeyDown))
{
vmcWaitForExit.WaitOne(); //this should just sit here until vmc is closed
}
}
_host = null; //host is invalid once Launch returns... make sure we don't use it after this
}
catch (Exception exc)
{
host.MediaCenterEnvironment.Dialog("Unable to launch. " + exc.ToString(),
"VMCMusicList", Microsoft.MediaCenter.DialogButtons.Ok, 0, true);
throw;
}
}
//*******This is the "key" bit - ahem ***********
private void hook_KeyDown(object sender, KeyEventArgs e) //handle the key
{
//Let's see what we have
_host.MediaCenterEnvironment.Dialog(e.KeyCode.ToString(), "", Microsoft.MediaCenter.DialogButtons.Ok, 0, true);
}
/// <summary>Gets a reference to the Process instance for the running ehshell.exe</summary>
private Process GetEhShellProcess()
{
// Get the current terminal services session ID
int currentSessionId;
using (Process currentProcess = Process.GetCurrentProcess()) currentSessionId = currentProcess.SessionId;
// Get all ehome processes on the machine, and find the one in the current session
Process[] procs = Process.GetProcessesByName("ehshell");
Process ehshell = null;
for (int i = 0; i < procs.Length; i++)
{
if (ehshell == null && procs[i].SessionId == currentSessionId) ehshell = procs[i];
else procs[i].Dispose();
}
return ehshell;
}
/// <summary>StephenToub's Simple implementation of a keyboard hook for key down events on the GUI thread of an application.</summary>
public sealed class KeyboardHook : IDisposable
{
/// <summary>Low-level keyboard hook id.</summary>
private const int WH_KEYBOARD_LL = 13;
/// <summary>Posted to the window with the keyboard focus when a nonsystem key is pressed.</summary>
private const int WM_KEYDOWN = 0x0100;
/// <summary>OS handle for the registered keyboard hook.</summary>
private SafeWindowsHookHandle _hookHandle = null;
/// <summary>Hook callback when a WH_KEYBOARD event occurs.</summary>
private LowLevelKeyboardProc _hookProc;
/// <summary>Delegate called when a key is pressed down.</summary>
private KeyEventHandler _keyDown;
/// <summary>Target process ID.</summary>
private int _pid;
/// <summary>Initializes the keyboard hook.</summary>
/// <param name="keyDown">The delegate to be called when a key down event occurs.</param>
public KeyboardHook(int targetProcessID, KeyEventHandler keyDown)
{
if (keyDown == null) throw new ArgumentNullException("keyDown");
// Store the user's KeyDown delegate
_keyDown = keyDown;
_pid = targetProcessID;
// Create the callback and make sure it doesn't get GC'd,
// since it'll be called from unmanaged code
_hookProc = new LowLevelKeyboardProc(HookCallback);
// Set the hook for just the GUI thread
using (Process curProcess = Process.GetCurrentProcess())
using (ProcessModule curModule = curProcess.MainModule)
{
_hookHandle = SafeWindowsHookHandle.SetWindowsHookEx(
WH_KEYBOARD_LL, _hookProc, GetModuleHandle(curModule.ModuleName), 0);
}
if (_hookHandle.IsInvalid)
{
Exception exc = new Win32Exception();
Dispose();
throw exc;
}
}
/// <summary>Dispose the KeyboardHook.</summary>
public void Dispose()
{
if (_hookHandle != null)
{
_hookHandle.Dispose();
_hookHandle = null;
}
}
/// <summary>Event raised when an exception is encountered from a callback.</summary>
public ErrorEventHandler Error = delegate { };
/// <summary>HookCallback data.</summary>
private struct KBDLLHOOKSTRUCT
{
#pragma warning disable 0649
public uint vkCode;
public uint scanCode;
public uint flags;
public uint time;
public IntPtr dwExtraInfo;
#pragma warning restore 0649
}
/// <summary>Callback from the installed hook.</summary>
///</returns>
private IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
bool handled = false;
try
{
// Only respond to key down events when the shift key isn't pressed
if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
{
uint pid;
GetWindowThreadProcessId(GetForegroundWindow(), out pid);
if (pid == _pid)
{
KBDLLHOOKSTRUCT hookParam = (KBDLLHOOKSTRUCT)Marshal.PtrToStructure(lParam, typeof(KBDLLHOOKSTRUCT));
Keys key = (Keys)hookParam.vkCode;
if (key == Keys.Packet) key = (Keys)hookParam.scanCode;
KeyEventArgs e = new KeyEventArgs(key | ModifierKeys);
_keyDown(this, e);
handled = e.Handled | e.SuppressKeyPress;
}
}
// If the event has not been handled/eaten by the user, relegate to the next hook in line.
return handled ?
new IntPtr(1) :
SafeWindowsHookHandle.CallNextHookEx(_hookHandle, nCode, wParam, lParam);
}
catch (Exception exc) { Error(this, new ErrorEventArgs(exc)); }
return new IntPtr(1);
}
/// <summary>Gets the modifier keys currently in use.</summary>
private static Keys ModifierKeys
{
get
{
Keys modifiers = Keys.None;
if (GetKeyState(VK_SHIFT) < 0) modifiers |= Keys.Shift;
if (GetKeyState(VK_CONTROL) < 0) modifiers |= Keys.Control;
if (GetKeyState(VK_ALT) < 0) modifiers |= Keys.Alt;
return modifiers;
}
}
/// <summary>
/// The GetWindowThreadProcessId function retrieves the identifier of the thread that created the specified window
/// and, optionally, the identifier of the process that created the window.
/// </summary>
/// <param name="hWnd">Handle to the window.</param>
/// <param name="lpdwProcessId">Pointer to a variable that receives the process identifier.</param>
/// <returns>The return value is the identifier of the thread that created the window.</returns>
[DllImport("user32.dll", SetLastError = true)]
private static extern uint GetWindowThreadProcessId(IntPtr hWnd, out uint lpdwProcessId);
/// <summary>Returns a handle to the foreground window (the window with which the user is currently working).</summary>
/// <returns>A handle to the foreground window.</returns>
[DllImport("user32.dll", SetLastError = true)]
private static extern IntPtr GetForegroundWindow();
/// <summary>Virtual key value for shift.</summary>
private const uint VK_SHIFT = 0x10;
private const uint VK_CONTROL = 0x11;
private const uint VK_ALT = 0x12;
/// <summary>The GetKeyState function retrieves the status of the specified virtual key.</summary>
/// <param name="nVirtKey">Specifies a virtual key.</param>
/// <returns>The return value specifies the status of the specified virtual key.</returns>
[DllImport("user32.dll", SetLastError = true)]
private static extern short GetKeyState(uint nVirtKey);
/// <summary>Retrieves a module handle for the specified module. The module must have been loaded by the calling process</summary>
/// <param name="lpModuleName">The name of the loaded module (either a .dll or .exe file).</param>
/// <returns>
/// If the function succeeds, the return value is a handle to the specified module.
/// If the function fails, the return value is NULL.
/// </returns>
[DllImport("kernel32.dll", SetLastError = true)]
private static extern IntPtr GetModuleHandle(string lpModuleName);
}
/// <summary>LowLevelKeyboardProc for callbacks from the OS.</summary>
internal delegate IntPtr LowLevelKeyboardProc(int nCode, IntPtr wParam, IntPtr lParam);
/// <summary>A SafeHandle for windows hook handles.</summary>
[SecurityPermission(SecurityAction.LinkDemand, UnmanagedCode = true)]
internal sealed class SafeWindowsHookHandle : SafeHandleZeroOrMinusOneIsInvalid
{
/// <summary>Initializes the SafeWindowsHookHandle.</summary>
private SafeWindowsHookHandle() : base(true) { }
/// <summary>Releases the handle.</summary>
/// <returns>true on success; false, otherwise.</returns>
protected override bool ReleaseHandle()
{
return UnhookWindowsHookEx(handle);
}
/// <summary>The UnhookWindowsHookEx function removes a hook procedure installed in a hook chain by the SetWindowsHookEx function.</summary>
/// <param name="hhk">Handle to the hook procedure</param>
/// <returns>true on success; otherwise, false.</returns>
[SuppressUnmanagedCodeSecurity]
[ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
[DllImport("user32.dll", SetLastError = true)]
[return: MarshalAs(UnmanagedType.Bool)]
private static extern bool UnhookWindowsHookEx(IntPtr hhk);
/// <summary>The SetWindowsHookEx function installs an application-defined hook procedure into a hook chain.</summary>
/// <param name="idHook">Specifies the type of hook procedure to be installed.</param>
/// <param name="lpfn">Pointer to the hook procedure.</param>
/// <param name="hMod">Handle to the DLL containing the hook procedure pointed to by the lpfn parameter.</param>
/// <param name="dwThreadId">Specifies the identifier of the thread with which the hook procedure is to be associated.</param>
/// <returns>If the function succeeds, the return value is the handle to the hook procedure; otherwise, 0.</returns>
[DllImport("user32.dll", SetLastError = true)]
public static extern SafeWindowsHookHandle SetWindowsHookEx(int idHook, LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);
/// <summary>The CallNextHookEx function passes the hook information to the next hook procedure in the current hook chain.</summary>
/// <param name="hhk">Handle to the current hook.</param>
/// <param name="nCode">Specifies the hook code passed to the current hook procedure.</param>
/// <param name="wParam">Specifies the wParam value passed to the current hook procedure.</param>
/// <param name="lParam">Specifies the lParam value passed to the current hook procedure.</param>
/// <returns>This value is returned by the next hook procedure in the chain.</returns>
[DllImport("user32.dll", SetLastError = true)]
public static extern IntPtr CallNextHookEx(SafeWindowsHookHandle hhk, int nCode, IntPtr wParam, IntPtr lParam);
}
}
}
Gordon: Has reached the end!