Code:
/ 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / wpf / src / Core / CSharp / System / Windows / InterOp / HwndKeyboardInputProvider.cs / 1305600 / HwndKeyboardInputProvider.cs
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Threading;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using MS.Utility;
using MS.Internal;
using MS.Internal.Interop;
using MS.Win32;
using MS.Internal.PresentationCore;
using SR=MS.Internal.PresentationCore.SR;
using SRID=MS.Internal.PresentationCore.SRID;
namespace System.Windows.Interop
{
internal sealed class HwndKeyboardInputProvider : DispatcherObject, IKeyboardInputProvider, IDisposable
{
///
/// Accesses and store critical data. This class is also critical (_site and _source)
///
[SecurityCritical]
internal HwndKeyboardInputProvider(HwndSource source)
{
(new UIPermission(PermissionState.Unrestricted)).Assert();
try //Blessed assert for InputManager.Current.RegisterInputProvider
{
_site = new SecurityCriticalDataClass(InputManager.Current.RegisterInputProvider(this));
}
finally
{
UIPermission.RevertAssert();
}
_source = new SecurityCriticalDataClass(source);
}
///
/// Critical:This class accesses critical data, _site.
/// TreatAsSafe: This class does not expose the critical data
///
[SecurityCritical, SecurityTreatAsSafe]
public void Dispose()
{
if(_site != null)
{
_site.Value.Dispose();
_site = null;
}
_source = null;
}
public void OnRootChanged(Visual oldRoot, Visual newRoot)
{
if(_active && newRoot != null)
{
Keyboard.Focus(null); // internally we will set the focus to the root.
}
}
///
/// Critical: As this accesses critical data HwndSource
/// TreatAsSafe:Information about whether a given input provider services
/// a visual is safe to expose. This method does not expose the critical data either.
///
[SecurityCritical,SecurityTreatAsSafe]
bool IInputProvider.ProvidesInputForRootVisual(Visual v)
{
Debug.Assert( null != _source );
return _source.Value.RootVisual == v;
}
void IInputProvider.NotifyDeactivate()
{
_active = false;
_partialActive = false;
}
///
/// SecurityCritical: This code calls into GetWindowLong/GetFocus both of which are
/// critical.It also retrieves the handle to the current
/// window that has focus.Additionally it also calls into SetFocus which also
/// returns a critical resouce in the form of a window handle. In this case all that is
/// retrieved is the extended window style and that data is not exposed.
/// It is simply used to detect if the window is set to WS_EX_NOACTIVATE.
/// The risky operation here is the call to SetFocus.
///
[SecurityCritical]
bool IKeyboardInputProvider.AcquireFocus(bool checkOnly)
{
bool success = false;
Debug.Assert( null != _source );
try
{
// Acquiring focus into this window should clear any pending focus restoration.
if(!checkOnly)
{
_restoreFocusWindow = IntPtr.Zero;
_restoreFocus = null;
}
HandleRef thisWindow = new HandleRef(this, _source.Value.CriticalHandle);
int windowStyle = UnsafeNativeMethods.GetWindowLong(thisWindow, NativeMethods.GWL_EXSTYLE);
if ((windowStyle & NativeMethods.WS_EX_NOACTIVATE) == NativeMethods.WS_EX_NOACTIVATE || _source.Value.IsInExclusiveMenuMode)
{
// If this window has the WS_EX_NOACTIVATE style, then we
// do not set Win32 keyboard focus to this window because
// that would actually activate the window. This is
// typically for the menu Popup.
//
// If this window is in "menu mode", then we do not set
// Win32 focus to this window because we don't want to
// move Win32 focus from where it is. This is typically
// for the main window.
//
// In either case, the window must be enabled.
if(SafeNativeMethods.IsWindowEnabled(thisWindow))
{
if (SecurityHelper.AppDomainGrantedUnrestrictedUIPermission)
{
// In fully-trusted AppDomains, the only hard requirement
// is that Win32 keyboard focus be somewhere on our thread,
// and that the message pump cooperate by calling
// ComponentDispatcher.RaiseThreadMessage. WPF will be
// able to route the keyboard events to the element with
// WPF keyboard focus, regardless of which window has Win32
// keyboard focus. Menus/ComboBoxes use this feature.
int idWindowProcess;
IntPtr focus = UnsafeNativeMethods.GetFocus();
int idWindowThread = UnsafeNativeMethods.GetWindowThreadProcessId(new HandleRef(null, focus), out idWindowProcess);
success = (idWindowThread == SafeNativeMethods.GetCurrentThreadId());
}
else
{
// In partially-trusted AppDomains, we do not want to expose input
// intended for other native windows, or for WPF windows in other
// AppDomains.
IntPtr focus = UnsafeNativeMethods.GetFocus();
success = IsOurWindow(focus);
}
}
}
else
{
// This is the normal case. We want to keep WPF keyboard
// focus and Win32 keyboard focus in [....].
if(!checkOnly)
{
UnsafeNativeMethods.SetFocus(thisWindow);
}
IntPtr focus = UnsafeNativeMethods.GetFocus();
success = (focus == _source.Value.CriticalHandle);
}
}
catch(System.ComponentModel.Win32Exception)
{
System.Diagnostics.Debug.WriteLine("HwndMouseInputProvider: AcquireFocus failed!");
}
return success;
}
//[CodeAnalysis("AptcaMethodsShouldOnlyCallAptcaMethods")] //Tracking Bug: 29647
///
/// Critical:
/// This code is critical since it handles all keyboard messages
/// and could be used to spoof input.
/// For HANDLED_KEYDOWN_STILL_GENERATES_CHARS we also cause the
/// Dispatcher to defer processing the queue until after any
/// currently pending messages.
///
[SecurityCritical]
internal IntPtr FilterMessage(IntPtr hwnd, WindowMessage message, IntPtr wParam, IntPtr lParam, ref bool handled)
{
IntPtr result = IntPtr.Zero ;
// It is possible to be re-entered during disposal. Just return.
if(null == _source || null == _source.Value)
{
return result;
}
_msgTime = 0;
try
{
_msgTime = SafeNativeMethods.GetMessageTime();
}
catch(System.ComponentModel.Win32Exception)
{
System.Diagnostics.Debug.WriteLine("HwndKeyboardInputProvider: GetMessageTime failed!");
}
switch(message)
{
// WM_KEYDOWN is sent when a nonsystem key is pressed.
// A nonsystem key is a key that is pressed when the ALT key
// is not pressed.
// WM_SYSKEYDOWN is sent when a system key is pressed.
case WindowMessage.WM_SYSKEYDOWN:
case WindowMessage.WM_KEYDOWN:
{
// If we have a IKeyboardInputSite, then we should have already
// called ProcessKeyDown (from TranslateAccelerator)
// But there are several paths (our message pump / app's message
// pump) where we do (or don't) call through IKeyboardInputSink.
// So the best way is to just check here if we already did it.
if(_source.Value.IsRepeatedKeyboardMessage(hwnd, (int)message, wParam, lParam))
{
break;
}
// We will use the current time before generating KeyDown events so we can filter
// the later posted WM_CHAR.
int currentTime = 0;
try
{
currentTime = SafeNativeMethods.GetTickCount();
}
catch(System.ComponentModel.Win32Exception)
{
System.Diagnostics.Debug.WriteLine("HwndMouseInputProvider: GetTickCount failed!");
}
// MITIGATION: HANDLED_KEYDOWN_STILL_GENERATES_CHARS
// In case a nested message pump is used before we return
// from processing this message, we disable processing the
// next WM_CHAR message because if the code pumps messages
// it should really mark the message as handled.
HwndSource._eatCharMessages = true;
DispatcherOperation restoreCharMessages = Dispatcher.BeginInvoke(DispatcherPriority.Normal, new DispatcherOperationCallback(HwndSource.RestoreCharMessages), null);
// Force the Dispatcher to post a new message to service any
// pending operations, so that the operation we just posted
// is guaranteed to get dispatched after any pending WM_CHAR
// messages are dispatched.
Dispatcher.CriticalRequestProcessing(true);
MSG msg = new MSG(hwnd, (int)message, wParam, lParam, _msgTime, 0, 0);
ProcessKeyAction(ref msg, ref handled);
if(!handled)
{
// MITIGATION: HANDLED_KEYDOWN_STILL_GENERATES_CHARS
// We did not handle the WM_KEYDOWN, so it is OK to process WM_CHAR messages.
// We can also abort the pending restore operation since we don't need it.
HwndSource._eatCharMessages = false;
restoreCharMessages.Abort();
}
// System.Console.WriteLine("KEYDOWN(message={0}, wParam={1})={2}", message, wParam, handled);
}
break;
// WM_KEYUP is sent when a nonsystem key is released.
// A nonsystem key is a key that is pressed when the ALT key
// is not pressed.
// WM_SYSKEYUP is sent when a system key is released.
case WindowMessage.WM_SYSKEYUP:
case WindowMessage.WM_KEYUP:
{
if(_source.Value.IsRepeatedKeyboardMessage(hwnd, (int)message, wParam, lParam))
{
break;
}
MSG msg = new MSG(hwnd, (int)message, wParam, lParam, _msgTime, 0, 0);
ProcessKeyAction(ref msg, ref handled);
// System.Console.WriteLine("KEYUP (message={0}, wParam={1})={2}", message, wParam, handled);
}
break;
//
case WindowMessage.WM_CHAR:
case WindowMessage.WM_DEADCHAR:
case WindowMessage.WM_SYSCHAR:
case WindowMessage.WM_SYSDEADCHAR:
{
if(_source.Value.IsRepeatedKeyboardMessage(hwnd, (int)message, wParam, lParam))
{
break;
}
// MITIGATION: HANDLED_KEYDOWN_STILL_GENERATES_CHARS
if(HwndSource._eatCharMessages)
{
break;
}
ProcessTextInputAction(hwnd, message, wParam, lParam, ref handled);
// System.Console.WriteLine("CHAR(message={0}, wParam={1})={2}", message, wParam, handled);
}
break;
case WindowMessage.WM_EXITMENULOOP:
case WindowMessage.WM_EXITSIZEMOVE:
{
// MITIGATION: KEYBOARD_STATE_OUT_OF_[....]
//
// Avalon relies on keeping it's copy of the keyboard
// state. This is for a number of reasons, including that
// we need to be able to give this state to worker threads.
//
// There are a number of cases where Win32 eats the
// keyboard messages, and this can cause our keyboard
// state to become stale. Obviously this can happen when
// another app is in the foreground, but we handle that
// by re-synching our keyboard state when we get focus.
//
// Other times are when Win32 enters a nested loop. While
// any one could enter a nested loop at any time for any
// reason, Win32 is nice enough to let us know when it is
// finished with the two common loops: menus and sizing.
// We re-[....] our keyboard device in response to these.
//
if(_active)
{
_partialActive = true;
ReportInput(hwnd,
InputMode.Foreground,
_msgTime,
RawKeyboardActions.Activate,
0,
false,
false,
0);
}
}
break;
// WM_SETFOCUS is sent immediately after focus is granted.
// This is our clue that the keyboard is active.
case WindowMessage.WM_SETFOCUS:
{
if(!_active)
{
// Console.WriteLine("WM_SETFOCUS");
ReportInput(hwnd,
InputMode.Foreground,
_msgTime,
RawKeyboardActions.Activate,
0,
false,
false,
0);
// MITIGATION: KEYBOARD_STATE_OUT_OF_[....]
//
// This is how we deal with the fact that Win32 sometimes sends
// us a WM_SETFOCUS message BEFORE it has updated it's internal
// internal keyboard state information. When we get the
// WM_SETFOCUS message, we activate the keyboard with the
// keyboard state (even though it could be wrong). Then when
// we get the first "real" keyboard input event, we activate
// the keyboard again, since Win32 will have updated the
// keyboard state correctly by then.
//
_partialActive = true;
if(_source.Value.RestoreFocusMode == RestoreFocusMode.Auto)
{
// Restore the keyboard focus to the child window or element that had
// the focus before we last lost Win32 focus. If nothing
// had focus before, set it to null.
if (_restoreFocusWindow != IntPtr.Zero)
{
IntPtr hwndRestoreFocus = _restoreFocusWindow;
_restoreFocusWindow = IntPtr.Zero;
UnsafeNativeMethods.TrySetFocus(new HandleRef(this, hwndRestoreFocus), ref hwndRestoreFocus);
}
else
{
DependencyObject restoreFocusDO = _restoreFocus as DependencyObject;
_restoreFocus = null;
if(restoreFocusDO != null)
{
// Only restore focus to an element if that
// element still belongs to this HWND.
HwndSource hwndSource = PresentationSource.CriticalFromVisual(restoreFocusDO) as HwndSource;
if (hwndSource != _source.Value)
{
restoreFocusDO = null;
}
}
// Try to restore focus to the last element that had focus. Note
// that if restoreFocusDO is null, we will internally set focus
// to the root element.
Keyboard.Focus(restoreFocusDO as IInputElement);
// Lots of things can happen when setting focus to an element,
// including that element may set focus somewhere else, possibly
// even into another HWND. However, if Win32 focus remains on
// this window, we do not allow the focused element to be in
// a different window.
IntPtr focus = UnsafeNativeMethods.GetFocus();
if (focus == _source.Value.CriticalHandle)
{
restoreFocusDO = (DependencyObject)Keyboard.FocusedElement;
if (restoreFocusDO != null)
{
HwndSource hwndSource = PresentationSource.CriticalFromVisual(restoreFocusDO) as HwndSource;
if (hwndSource != _source.Value)
{
Keyboard.ClearFocus();
}
}
}
}
}
}
handled = true;
}
break;
// WM_KILLFOCUS is sent immediately before focus is removed.
// This is our clue that the keyboard is inactive.
case WindowMessage.WM_KILLFOCUS:
{
if(_active && wParam != _source.Value.CriticalHandle )
{
// Console.WriteLine("WM_KILLFOCUS");
if(_source.Value.RestoreFocusMode == RestoreFocusMode.Auto)
{
// when the window that's acquiring focus (wParam) is
// a descendant of our window, remember the immediate
// child so that we can restore focus to it.
_restoreFocusWindow = GetImmediateChildFor((IntPtr)wParam, _source.Value.CriticalHandle);
_restoreFocus = null;
// If we aren't restoring focus to a child window,
// then restore focus to the element that currently
// has WPF keyboard focus if it is directly in this
// HwndSource.
if (_restoreFocusWindow == IntPtr.Zero)
{
DependencyObject focusedDO = Keyboard.FocusedElement as DependencyObject;
if (focusedDO != null)
{
HwndSource hwndSource = PresentationSource.CriticalFromVisual(focusedDO) as HwndSource;
if (hwndSource == _source.Value)
{
_restoreFocus = focusedDO as IInputElement;
}
}
}
}
PossiblyDeactivate((IntPtr)wParam);
}
handled = true;
}
break;
// WM_UPDATEUISTATE is sent when the user presses ALT, expecting
// the app to display accelerator keys. We don't always hear the
// keystroke - another message loop may handle it. So report it
// here.
case WindowMessage.WM_UPDATEUISTATE:
{
RawUIStateInputReport report =
new RawUIStateInputReport(_source.Value,
InputMode.Foreground,
_msgTime,
(RawUIStateActions)NativeMethods.SignedLOWORD((int)wParam),
(RawUIStateTargets)NativeMethods.SignedHIWORD((int)wParam));
_site.Value.ReportInput(report);
handled = true;
}
break;
}
if (handled && EventTrace.IsEnabled(EventTrace.Keyword.KeywordInput | EventTrace.Keyword.KeywordPerf, EventTrace.Level.Info))
{
EventTrace.EventProvider.TraceEvent(EventTrace.Event.WClientInputMessage,
EventTrace.Keyword.KeywordInput | EventTrace.Keyword.KeywordPerf, EventTrace.Level.Info,
Dispatcher.GetHashCode(),
hwnd.ToInt64(),
message,
(int)wParam,
(int)lParam);
}
return result;
}
///
/// Critical:This can be used to spoof input
///
[SecurityCritical]
internal void ProcessKeyAction(ref MSG msg, ref bool handled)
{
// Remember the last message
MSG previousMSG = ComponentDispatcher.UnsecureCurrentKeyboardMessage;
ComponentDispatcher.UnsecureCurrentKeyboardMessage = msg;
try
{
int virtualKey = GetVirtualKey(msg.wParam, msg.lParam);
int scanCode = GetScanCode(msg.wParam, msg.lParam);
bool isExtendedKey = IsExtendedKey(msg.lParam);
bool isSystemKey = (((WindowMessage)msg.message == WindowMessage.WM_SYSKEYDOWN) || ((WindowMessage)msg.message == WindowMessage.WM_SYSKEYUP));
RawKeyboardActions action = GetKeyUpKeyDown((WindowMessage)msg.message);
// Console.WriteLine("WM_KEYDOWN: " + virtualKey + "," + scanCode);
handled = ReportInput(msg.hwnd,
InputMode.Foreground,
_msgTime,
action,
scanCode,
isExtendedKey,
isSystemKey,
virtualKey);
}
finally
{
// Restore the last message
ComponentDispatcher.UnsecureCurrentKeyboardMessage = previousMSG;
}
}
///
/// Critical - calls a critical method _source.Value.
///
[SecurityCritical ]
internal void ProcessTextInputAction(IntPtr hwnd, WindowMessage msg, IntPtr wParam, IntPtr lParam, ref bool handled)
{
char charcode = (char)wParam;
bool isDeadChar = ((msg == WindowMessage.WM_DEADCHAR) || (msg == WindowMessage.WM_SYSDEADCHAR));
bool isSystemChar = ((msg == WindowMessage.WM_SYSCHAR) || (msg == WindowMessage.WM_SYSDEADCHAR));
bool isControlChar = false;
// If the control is pressed but Alt is not, the char is control char.
try
{
if (((UnsafeNativeMethods.GetKeyState(NativeMethods.VK_CONTROL) & 0x8000) != 0) &&
((UnsafeNativeMethods.GetKeyState(NativeMethods.VK_MENU) & 0x8000) == 0) &&
Char.IsControl(charcode))
{
isControlChar = true;
}
}
catch(System.ComponentModel.Win32Exception)
{
System.Diagnostics.Debug.WriteLine("HwndMouseInputProvider: GetKeyState failed!");
}
RawTextInputReport report = new RawTextInputReport(_source.Value ,
InputMode.Foreground,
_msgTime,
isDeadChar,
isSystemChar,
isControlChar,
charcode);
handled = _site.Value.ReportInput(report);
}
internal static int GetVirtualKey(IntPtr wParam, IntPtr lParam)
{
int virtualKey = NativeMethods.IntPtrToInt32( wParam);
int scanCode = 0;
int keyData = NativeMethods.IntPtrToInt32(lParam);
// Find the left/right instance SHIFT keys.
if(virtualKey == NativeMethods.VK_SHIFT)
{
scanCode = (keyData & 0xFF0000) >> 16;
try
{
virtualKey = SafeNativeMethods.MapVirtualKey(scanCode, 3);
if(virtualKey == 0)
{
virtualKey = NativeMethods.VK_LSHIFT;
}
}
catch(System.ComponentModel.Win32Exception)
{
System.Diagnostics.Debug.WriteLine("HwndMouseInputProvider: MapVirtualKey failed!");
virtualKey = NativeMethods.VK_LSHIFT;
}
}
// Find the left/right instance ALT keys.
if(virtualKey == NativeMethods.VK_MENU)
{
bool right = ((keyData & 0x1000000) >> 24) != 0;
if(right)
{
virtualKey = NativeMethods.VK_RMENU;
}
else
{
virtualKey = NativeMethods.VK_LMENU;
}
}
// Find the left/right instance CONTROL keys.
if(virtualKey == NativeMethods.VK_CONTROL)
{
bool right = ((keyData & 0x1000000) >> 24) != 0;
if(right)
{
virtualKey = NativeMethods.VK_RCONTROL;
}
else
{
virtualKey = NativeMethods.VK_LCONTROL;
}
}
return virtualKey;
}
internal static int GetScanCode(IntPtr wParam, IntPtr lParam)
{
int keyData = NativeMethods.IntPtrToInt32(lParam);
int scanCode = (keyData & 0xFF0000) >> 16;
if(scanCode == 0)
{
try
{
int virtualKey = GetVirtualKey(wParam, lParam);
scanCode = SafeNativeMethods.MapVirtualKey(virtualKey, 0);
}
catch(System.ComponentModel.Win32Exception)
{
System.Diagnostics.Debug.WriteLine("HwndMouseInputProvider: MapVirtualKey failed!");
}
}
return scanCode;
}
internal static bool IsExtendedKey(IntPtr lParam)
{
int keyData = NativeMethods.IntPtrToInt32(lParam);
return ((keyData & 0x01000000) != 0) ? true : false;
}
///
/// Returns the set of modifier keys currently pressed as determined by calling to Win32
///
///
/// Marked as FriendAccessAllowed so HwndHost in PresentationFramework can call it
///
///
/// Critical: It calls an UnsafeNativeMethod (GetKeyState).
/// TreatAsSafe: It's safe to return whether shift, control or alt keys are being pressed or not.
///
[FriendAccessAllowed]
[SecurityCritical,SecurityTreatAsSafe]
internal static ModifierKeys GetSystemModifierKeys()
{
ModifierKeys modifierKeys = ModifierKeys.None;
short keyState = UnsafeNativeMethods.GetKeyState(NativeMethods.VK_SHIFT);
if((keyState & 0x8000) == 0x8000)
{
modifierKeys |= ModifierKeys.Shift;
}
keyState = UnsafeNativeMethods.GetKeyState(NativeMethods.VK_CONTROL);
if((keyState & 0x8000) == 0x8000)
{
modifierKeys |= ModifierKeys.Control;
}
keyState = UnsafeNativeMethods.GetKeyState(NativeMethods.VK_MENU);
if((keyState & 0x8000) == 0x8000)
{
modifierKeys |= ModifierKeys.Alt;
}
return modifierKeys;
}
private RawKeyboardActions GetKeyUpKeyDown(WindowMessage msg)
{
if( msg == WindowMessage.WM_KEYDOWN || msg == WindowMessage.WM_SYSKEYDOWN )
return RawKeyboardActions.KeyDown;
if( msg == WindowMessage.WM_KEYUP || msg == WindowMessage.WM_SYSKEYUP )
return RawKeyboardActions.KeyUp;
throw new ArgumentException(SR.Get(SRID.OnlyAcceptsKeyMessages));
}
///
/// Critical: This code causes this window to loose focus not ok to expose
/// It also calls into a critical code path.
///
[SecurityCritical]
private void PossiblyDeactivate(IntPtr hwndFocus)
{
Debug.Assert( null != _source );
// We are now longer active ourselves, but it is possible that the
// window the keyboard is going to intereact with is in the same
// Dispatcher as ourselves. If so, we don't want to deactivate the
// keyboard input stream because the other window hasn't activated
// it yet, and it may result in the input stream "flickering" between
// active/inactive/active. This is ugly, so we try to supress the
// uneccesary transitions.
//
bool deactivate = !IsOurWindow(hwndFocus);
// This window itself should not be active anymore.
_active = false;
// Only deactivate the keyboard input stream if needed.
if(deactivate)
{
ReportInput(_source.Value.CriticalHandle,
InputMode.Foreground,
_msgTime,
RawKeyboardActions.Deactivate,
0,
false,
false,
0);
}
}
///
/// Critical: This code does not store any critical data, it accesses PresentationSource
/// TreatAsSafe: This information is safe to expose
///
[SecurityCritical,SecurityTreatAsSafe]
private bool IsOurWindow(IntPtr hwnd)
{
bool isOurWindow = false;
Debug.Assert( null != _source );
if(hwnd != IntPtr.Zero)
{
HwndSource hwndSource = HwndSource.CriticalFromHwnd(hwnd);
if(hwndSource != null)
{
if(hwndSource.Dispatcher == _source.Value.Dispatcher)
{
// The window has the same dispatcher, must be ours.
isOurWindow = true;
}
else
{
// The window has a different dispatcher, must not be ours.
isOurWindow = false;
}
}
else
{
// The window is non-Avalon.
// Such windows are never ours.
isOurWindow = false;
}
}
else
{
// This is not even a window.
isOurWindow = false;
}
return isOurWindow;
}
// return the immediate child (if any) of hwndRoot that governs the
// given hwnd. If hwnd is not a descendant of hwndRoot, return 0.
///
/// Critical:This method calls critical methods
///
[SecurityCritical]
private IntPtr GetImmediateChildFor(IntPtr hwnd, IntPtr hwndRoot)
{
while (hwnd != IntPtr.Zero)
{
// We only care to restore focus to child windows. Notice that WS_POPUP
// windows also have parents but we do not want to track those here.
int windowStyle = UnsafeNativeMethods.GetWindowLong(new HandleRef(this,hwnd), NativeMethods.GWL_STYLE);
if((windowStyle & NativeMethods.WS_CHILD) == 0)
{
break;
}
IntPtr hwndParent = UnsafeNativeMethods.GetParent(new HandleRef(this, hwnd));
if (hwndParent == hwndRoot)
{
return hwnd;
}
hwnd = hwndParent;
}
return IntPtr.Zero;
}
///
/// Critical:This code can cause input simulation and hence is critical.
/// The current code path is only hit under RootBrowserWindow scenario for now.
///
[SecurityCritical]
private bool ReportInput(
IntPtr hwnd,
InputMode mode,
int timestamp,
RawKeyboardActions actions,
int scanCode,
bool isExtendedKey,
bool isSystemKey,
int virtualKey)
{
Debug.Assert( null != _source );
// The first event should also activate the keyboard device.
if((actions & RawKeyboardActions.Deactivate) == 0)
{
if(!_active || _partialActive)
{
try
{
// Include the activation action.
actions |= RawKeyboardActions.Activate;
// Remember that we are active.
_active = true;
_partialActive = false;
}
catch(System.ComponentModel.Win32Exception)
{
System.Diagnostics.Debug.WriteLine("HwndMouseInputProvider: GetKeyboardState failed!");
// We'll go ahead and report the input, but we'll try to "activate" next time.
}
}
}
// Get the extra information sent along with the message.
IntPtr extraInformation = IntPtr.Zero;
try
{
extraInformation = UnsafeNativeMethods.GetMessageExtraInfo();
}
catch(System.ComponentModel.Win32Exception)
{
System.Diagnostics.Debug.WriteLine("HwndMouseInputProvider: GetMessageExtraInfo failed!");
}
RawKeyboardInputReport report = new RawKeyboardInputReport(_source.Value,
mode,
timestamp,
actions,
scanCode,
isExtendedKey,
isSystemKey,
virtualKey,
extraInformation);
bool handled = _site.Value.ReportInput(report);
return handled;
}
private int _msgTime;
///
/// This is got under an elevation and is hence critical. This data is not ok to expose.
///
private SecurityCriticalDataClass _source;
///
/// This is got under an elevation and is hence critical.This data is not ok to expose.
///
private SecurityCriticalDataClass _site;
private IInputElement _restoreFocus;
///
/// This is got under an elevation and is hence critical.This data is not ok to expose.
///
[SecurityCritical]
private IntPtr _restoreFocusWindow;
private bool _active;
private bool _partialActive;
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- AssertSection.cs
- SqlDataSource.cs
- DoubleAnimation.cs
- ExpressionBuilderCollection.cs
- TextLine.cs
- XmlCodeExporter.cs
- CompoundFileIOPermission.cs
- ParserOptions.cs
- DialogResultConverter.cs
- LayoutTableCell.cs
- TextSchema.cs
- NativeMethods.cs
- EntityFrameworkVersions.cs
- InvalidAsynchronousStateException.cs
- CompoundFileStreamReference.cs
- XmlName.cs
- VirtualPathUtility.cs
- RegionInfo.cs
- MorphHelper.cs
- WindowsContainer.cs
- FormsAuthenticationCredentials.cs
- FlowDocument.cs
- ProcessHostServerConfig.cs
- SafeTimerHandle.cs
- XMLSchema.cs
- MarkupCompilePass1.cs
- Attributes.cs
- TransactionContext.cs
- PrtTicket_Editor.cs
- DataSourceCache.cs
- IsolatedStorageFilePermission.cs
- XPathNodePointer.cs
- InternalPermissions.cs
- CodeParameterDeclarationExpressionCollection.cs
- Viewport3DAutomationPeer.cs
- PrintingPermission.cs
- TreeBuilder.cs
- ObjectPersistData.cs
- CodeAssignStatement.cs
- TypeResolver.cs
- StylusPlugInCollection.cs
- TextRangeBase.cs
- CircleHotSpot.cs
- Unit.cs
- RegexFCD.cs
- EllipticalNodeOperations.cs
- WebBrowserHelper.cs
- ImportException.cs
- Pen.cs
- ColumnWidthChangingEvent.cs
- GeometryGroup.cs
- TypeNameParser.cs
- XmlSchemaExternal.cs
- InstalledFontCollection.cs
- ReadContentAsBinaryHelper.cs
- PropertyValueUIItem.cs
- SqlAliaser.cs
- OleDbDataAdapter.cs
- BevelBitmapEffect.cs
- RequestCacheEntry.cs
- X509Chain.cs
- CompilationUtil.cs
- XmlSchemaInferenceException.cs
- WebPartConnectionsCancelVerb.cs
- Line.cs
- KeyGestureConverter.cs
- SmiEventSink_Default.cs
- ImageFormat.cs
- ConfigXmlSignificantWhitespace.cs
- DataServices.cs
- InternalPermissions.cs
- FolderBrowserDialog.cs
- ChangeNode.cs
- PrinterResolution.cs
- FilteredDataSetHelper.cs
- HMAC.cs
- FixedSOMPageElement.cs
- PngBitmapEncoder.cs
- XsltContext.cs
- FieldBuilder.cs
- TextChangedEventArgs.cs
- Event.cs
- XmlSignatureManifest.cs
- TextElementEditingBehaviorAttribute.cs
- ScriptMethodAttribute.cs
- BasicExpressionVisitor.cs
- MailFileEditor.cs
- MessageAction.cs
- Expander.cs
- DataGridViewComboBoxCell.cs
- DataGridViewColumnHeaderCell.cs
- FlagPanel.cs
- RegionInfo.cs
- VisualProxy.cs
- RadioButtonList.cs
- LocatorGroup.cs
- DocumentViewerBaseAutomationPeer.cs
- ClientConfigPaths.cs
- FontStyle.cs
- ManagementException.cs