Hi Brian,

Word still runs in its own process even you're hosting the ole document in
your WinForm (you can observe the WinWord.exe process in task manager).
Therefore, it's difficult for WinForm's PreviewKeyDown to intercept the F1
key from seeing by WinWord. We will need a low level keyboard hook in your
process to intercept the key.

#SetWindowsHookEx Function ()
http://msdn2.microsoft.com/en-us/library/ms644990.aspx

I've created following class to do hook the keyboard:

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.Windows.Forms;

namespace WindowsApplication1
{
   class KeyboardHook : IDisposable
   {
       private const int WH_KEYBOARD_LL = 13;
       private const int WM_KEYDOWN = 0x0100;
       private IntPtr _hookID = IntPtr.Zero;

       public event KeyEventHandler KeyDown;

       public KeyboardHook()
       {
           _hookID = SetHook(new LowLevelKeyboardProc(HookCallback));
       }

       #region IDisposable Members

       public void Dispose()
       {
           UnhookWindowsHookEx(_hookID);
       }

       #endregion

       private IntPtr SetHook(LowLevelKeyboardProc proc)
       {
           using (Process curProcess = Process.GetCurrentProcess())
           using (ProcessModule curModule = curProcess.MainModule)
           {
               return SetWindowsHookEx(WH_KEYBOARD_LL, proc,
                   GetModuleHandle(curModule.ModuleName), 0);
           }
       }

       private delegate IntPtr LowLevelKeyboardProc(
           int nCode, IntPtr wParam, IntPtr lParam);

       private IntPtr HookCallback(
           int nCode, IntPtr wParam, IntPtr lParam)
       {
           if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
           {
               int vkCode = Marshal.ReadInt32(lParam);
               Keys key = (Keys)vkCode;
               if (KeyDown != null)
               {
                   KeyEventArgs args = new KeyEventArgs(key);
                   KeyDown(this, args);
                   if (args.Handled)
                   {
                       return new IntPtr(1);   // indicate processed
                   }
               }
           }
           return CallNextHookEx(_hookID, nCode, wParam, lParam);
       }

       [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError =
true)]
       private static extern IntPtr SetWindowsHookEx(int idHook,
           LowLevelKeyboardProc lpfn, IntPtr hMod, uint dwThreadId);

       [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError =
true)]
       [return: MarshalAs(UnmanagedType.Bool)]
       private static extern bool UnhookWindowsHookEx(IntPtr hhk);

       [DllImport("user32.dll", CharSet = CharSet.Auto, SetLastError =
true)]
       private static extern IntPtr CallNextHookEx(IntPtr hhk, int nCode,
           IntPtr wParam, IntPtr lParam);

       [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError =
true)]
       private static extern IntPtr GetModuleHandle(string lpModuleName);
   }
}

To install the hook, modify your Program.cs as:

   static class Program
   {
       public static KeyboardHook kh;

       [STAThread]
       static void Main()
       {
           Application.EnableVisualStyles();
           Application.SetCompatibleTextRenderingDefault(false);
           using (kh = new KeyboardHook())
           {
               Application.Run(new Form1());
           }
       }
   }

The class KeyboardHook will raise an event KeyDown whenever a key is
intercepted, however, according to documentation:

#LowLevelKeyboardProc Function ()
http://msdn2.microsoft.com/en-us/library/ms644985.aspx

It's recommended not to cause too much delay when handling the hook
message; and I understand you're probably using a modal dialog when the F1
is pressed, therefore I suggest use a timer to delay the showing of the
modal dialog:

   public partial class Form1 : Form
   {
       public Form1()
       {
           InitializeComponent();

           Program.kh.KeyDown += new KeyEventHandler(kh_KeyDown);
       }

       private bool fInCall = false;
       private Timer tmrDelayedCall;

       void kh_KeyDown(object sender, KeyEventArgs e)
       {
           if (e.KeyCode == Keys.F1 && !fInCall)
           {
               e.Handled = true;
               fInCall = true;
               tmrDelayedCall = new Timer();
               tmrDelayedCall.Interval = 1;
               tmrDelayedCall.Tick += new
EventHandler(tmrDelayedCall_Tick);
               tmrDelayedCall.Start();
           }
       }

       void tmrDelayedCall_Tick(object sender, EventArgs e)
       {
           tmrDelayedCall.Stop();
           MessageBox.Show("F1");
           fInCall = false;
       }
   }

Intercepting all keys in the hook and raise events for them may not be
necessary if you only need to intercept the F1 key, you can check the key
in the hook and raise event accordingly.

Please try this and let me know the result on your side. Thanks.

Sincerely,
Walter Wang (wawang@online.microsoft.com, remove 'online.')
Microsoft Online Community Support

==================================================
Get notification to my posts through email? Please refer to
http://msdn.microsoft.com/subscriptions/managednewsgroups/default.aspx#notif
ications. If you are using Outlook Express, please make sure you clear the
check box "Tools/Options/Read: Get 300 headers at a time" to see your reply
promptly.

Note: The MSDN Managed Newsgroup support offering is for non-urgent issues
where an initial response from the community or a Microsoft Support
Engineer within 1 business day is acceptable. Please note that each follow
up response may take approximately 2 business days as the support
professional working with you may need further investigation to reach the
most efficient resolution. The offering is not appropriate for situations
that require urgent, real-time or phone-based interactions or complex
project analysis and dump analysis issues. Issues of this nature are best
handled working with a dedicated Microsoft Support Engineer by contacting
Microsoft Customer Support Services (CSS) at
http://msdn.microsoft.com/subscriptions/support/default.aspx.
==================================================

This posting is provided "AS IS" with no warranties, and confers no rights.