private void PostProcessInput(object sender, ProcessInputEventArgs e) { InputEventArgs inputEventArgs = e.StagingItem.Input; if ((inputEventArgs != null) && (inputEventArgs.Device == this)) { if (inputEventArgs.Handled) { RoutedEvent routedEvent = inputEventArgs.RoutedEvent; if (routedEvent == Touch.PreviewTouchMoveEvent || routedEvent == Touch.TouchMoveEvent) { _lastMoveHandled = true; } else if (routedEvent == Touch.PreviewTouchDownEvent || routedEvent == Touch.TouchDownEvent) { _lastDownHandled = true; } else if (routedEvent == Touch.PreviewTouchUpEvent || routedEvent == Touch.TouchUpEvent) { _lastUpHandled = true; } } else { bool forManipulation; RoutedEvent promotedTouchEvent = PromotePreviewToMain(inputEventArgs.RoutedEvent, out forManipulation); if (promotedTouchEvent != null) { TouchEventArgs promotedTouchEventArgs = CreateEventArgs(promotedTouchEvent); e.PushInput(promotedTouchEventArgs, e.StagingItem); } else if (forManipulation) { UIElement manipulatableElement = GetManipulatableElement(); if (manipulatableElement != null) { PromoteMainToManipulation(manipulatableElement, (TouchEventArgs)inputEventArgs); } } } } }
private void PostProcessInput(object sender, ProcessInputEventArgs e) { if (e.StagingItem.Input.RoutedEvent == InputManager.InputReportEvent) { if (!e.StagingItem.Input.Handled) { InputReportEventArgs inputReportEventArgs = e.StagingItem.Input as InputReportEventArgs; if (inputReportEventArgs != null) { RawAppCommandInputReport rawAppCommandInputReport = inputReportEventArgs.Report as RawAppCommandInputReport; if (rawAppCommandInputReport != null) { IInputElement commandTarget = e.StagingItem.Input.OriginalSource as IInputElement; if (commandTarget != null) { RoutedCommand command = GetRoutedCommand(rawAppCommandInputReport.AppCommand); if (command != null) { // Send the app command to the tree to be handled by UIElements and ContentElements // that will forward the event to CommandManager. CommandDeviceEventArgs args = new CommandDeviceEventArgs(this, rawAppCommandInputReport.Timestamp, command); args.RoutedEvent = CommandDeviceEvent; args.Source = commandTarget; e.PushInput(args, e.StagingItem); } } } } } } else if (e.StagingItem.Input.RoutedEvent == Keyboard.KeyUpEvent || e.StagingItem.Input.RoutedEvent == Mouse.MouseUpEvent || e.StagingItem.Input.RoutedEvent == Keyboard.GotKeyboardFocusEvent || e.StagingItem.Input.RoutedEvent == Keyboard.LostKeyboardFocusEvent) { CommandManager.InvalidateRequerySuggested(); } }
private void PostProcessInput(object sender, ProcessInputEventArgs e) { // PreviewKeyDown --> KeyDown if(e.StagingItem.Input.RoutedEvent == Keyboard.PreviewKeyDownEvent) { CheckForDisconnectedFocus(); if(!e.StagingItem.Input.Handled) { KeyEventArgs previewKeyDown = (KeyEventArgs) e.StagingItem.Input; // Dig out the real key. bool isSystemKey = false; bool isImeProcessed = false; bool isDeadCharProcessed = false; Key key = previewKeyDown.Key; if (key == Key.System) { isSystemKey = true; key = previewKeyDown.RealKey; } else if (key == Key.ImeProcessed) { isImeProcessed = true; key = previewKeyDown.RealKey; } else if (key == Key.DeadCharProcessed) { isDeadCharProcessed = true; key = previewKeyDown.RealKey; } KeyEventArgs keyDown = new KeyEventArgs(this, previewKeyDown.UnsafeInputSource, previewKeyDown.Timestamp, key); keyDown.SetRepeat( previewKeyDown.IsRepeat ); // Mark the new event as SystemKey as appropriate. if (isSystemKey) { keyDown.MarkSystem(); } else if (isImeProcessed) { // Mark the new event as ImeProcessed as appropriate. keyDown.MarkImeProcessed(); } else if (isDeadCharProcessed) { keyDown.MarkDeadCharProcessed(); } keyDown.RoutedEvent=Keyboard.KeyDownEvent; keyDown.ScanCode = previewKeyDown.ScanCode; keyDown.IsExtendedKey = previewKeyDown.IsExtendedKey; e.PushInput(keyDown, e.StagingItem); } } // PreviewKeyUp --> KeyUp if(e.StagingItem.Input.RoutedEvent == Keyboard.PreviewKeyUpEvent) { CheckForDisconnectedFocus(); if(!e.StagingItem.Input.Handled) { KeyEventArgs previewKeyUp = (KeyEventArgs) e.StagingItem.Input; // Dig out the real key. bool isSystemKey = false; bool isImeProcessed = false; bool isDeadCharProcessed = false; Key key = previewKeyUp.Key; if (key == Key.System) { isSystemKey = true; key = previewKeyUp.RealKey; } else if (key == Key.ImeProcessed) { isImeProcessed = true; key = previewKeyUp.RealKey; } else if(key == Key.DeadCharProcessed) { isDeadCharProcessed = true; key = previewKeyUp.RealKey; } KeyEventArgs keyUp = new KeyEventArgs(this, previewKeyUp.UnsafeInputSource, previewKeyUp.Timestamp, key); // Mark the new event as SystemKey as appropriate. if (isSystemKey) { keyUp.MarkSystem(); } else if (isImeProcessed) { // Mark the new event as ImeProcessed as appropriate. keyUp.MarkImeProcessed(); } else if (isDeadCharProcessed) { keyUp.MarkDeadCharProcessed(); } keyUp.RoutedEvent=Keyboard.KeyUpEvent; keyUp.ScanCode = previewKeyUp.ScanCode; keyUp.IsExtendedKey = previewKeyUp.IsExtendedKey; e.PushInput(keyUp, e.StagingItem); } } RawKeyboardInputReport keyboardInput = ExtractRawKeyboardInputReport(e, InputManager.InputReportEvent); if(keyboardInput != null) { CheckForDisconnectedFocus(); if(!e.StagingItem.Input.Handled) { // In general, this is where we promote the non-redundant // reported actions to our premier events. RawKeyboardActions actions = GetNonRedundantActions(e); // Raw --> PreviewKeyDown if((actions & RawKeyboardActions.KeyDown) == RawKeyboardActions.KeyDown) { Key key = (Key) e.StagingItem.GetData(_tagKey); if(key != Key.None) { KeyEventArgs previewKeyDown = new KeyEventArgs(this, keyboardInput.InputSource, keyboardInput.Timestamp, key); ScanCode scanCode = (ScanCode)e.StagingItem.GetData(_tagScanCode); previewKeyDown.ScanCode = scanCode.Code; previewKeyDown.IsExtendedKey = scanCode.IsExtended; if (keyboardInput.IsSystemKey) { previewKeyDown.MarkSystem(); } previewKeyDown.RoutedEvent=Keyboard.PreviewKeyDownEvent; e.PushInput(previewKeyDown, e.StagingItem); } } // Raw --> PreviewKeyUp if((actions & RawKeyboardActions.KeyUp) == RawKeyboardActions.KeyUp) { Key key = (Key) e.StagingItem.GetData(_tagKey); if(key != Key.None) { KeyEventArgs previewKeyUp = new KeyEventArgs(this, keyboardInput.InputSource, keyboardInput.Timestamp, key); ScanCode scanCode = (ScanCode)e.StagingItem.GetData(_tagScanCode); previewKeyUp.ScanCode = scanCode.Code; previewKeyUp.IsExtendedKey = scanCode.IsExtended; if (keyboardInput.IsSystemKey) { previewKeyUp.MarkSystem(); } previewKeyUp.RoutedEvent=Keyboard.PreviewKeyUpEvent; e.PushInput(previewKeyUp, e.StagingItem); } } } // Deactivate if((keyboardInput.Actions & RawKeyboardActions.Deactivate) == RawKeyboardActions.Deactivate) { if(IsActive) { _activeSource = null; // Even if handled, a keyboard deactivate results in a lost focus. ChangeFocus(null, e.StagingItem.Input.Timestamp); } } } }
private void PostProcessInput(object sender, ProcessInputEventArgs e) { // PreviewKeyDown --> KeyDown if (e.StagingItem.Input.RoutedEvent == Keyboard.PreviewKeyDownEvent) { CheckForDisconnectedFocus(); if (!e.StagingItem.Input.Handled) { KeyEventArgs previewKeyDown = (KeyEventArgs)e.StagingItem.Input; // Dig out the real key. bool isSystemKey = false; bool isImeProcessed = false; bool isDeadCharProcessed = false; Key key = previewKeyDown.Key; if (key == Key.System) { isSystemKey = true; key = previewKeyDown.RealKey; } else if (key == Key.ImeProcessed) { isImeProcessed = true; key = previewKeyDown.RealKey; } else if (key == Key.DeadCharProcessed) { isDeadCharProcessed = true; key = previewKeyDown.RealKey; } KeyEventArgs keyDown = new KeyEventArgs(this, previewKeyDown.UnsafeInputSource, previewKeyDown.Timestamp, key); keyDown.SetRepeat(previewKeyDown.IsRepeat); // Mark the new event as SystemKey as appropriate. if (isSystemKey) { keyDown.MarkSystem(); } else if (isImeProcessed) { // Mark the new event as ImeProcessed as appropriate. keyDown.MarkImeProcessed(); } else if (isDeadCharProcessed) { keyDown.MarkDeadCharProcessed(); } keyDown.RoutedEvent = Keyboard.KeyDownEvent; keyDown.ScanCode = previewKeyDown.ScanCode; keyDown.IsExtendedKey = previewKeyDown.IsExtendedKey; e.PushInput(keyDown, e.StagingItem); } } // PreviewKeyUp --> KeyUp if (e.StagingItem.Input.RoutedEvent == Keyboard.PreviewKeyUpEvent) { CheckForDisconnectedFocus(); if (!e.StagingItem.Input.Handled) { KeyEventArgs previewKeyUp = (KeyEventArgs)e.StagingItem.Input; // Dig out the real key. bool isSystemKey = false; bool isImeProcessed = false; bool isDeadCharProcessed = false; Key key = previewKeyUp.Key; if (key == Key.System) { isSystemKey = true; key = previewKeyUp.RealKey; } else if (key == Key.ImeProcessed) { isImeProcessed = true; key = previewKeyUp.RealKey; } else if (key == Key.DeadCharProcessed) { isDeadCharProcessed = true; key = previewKeyUp.RealKey; } KeyEventArgs keyUp = new KeyEventArgs(this, previewKeyUp.UnsafeInputSource, previewKeyUp.Timestamp, key); // Mark the new event as SystemKey as appropriate. if (isSystemKey) { keyUp.MarkSystem(); } else if (isImeProcessed) { // Mark the new event as ImeProcessed as appropriate. keyUp.MarkImeProcessed(); } else if (isDeadCharProcessed) { keyUp.MarkDeadCharProcessed(); } keyUp.RoutedEvent = Keyboard.KeyUpEvent; keyUp.ScanCode = previewKeyUp.ScanCode; keyUp.IsExtendedKey = previewKeyUp.IsExtendedKey; e.PushInput(keyUp, e.StagingItem); } } RawKeyboardInputReport keyboardInput = ExtractRawKeyboardInputReport(e, InputManager.InputReportEvent); if (keyboardInput != null) { CheckForDisconnectedFocus(); if (!e.StagingItem.Input.Handled) { // In general, this is where we promote the non-redundant // reported actions to our premier events. RawKeyboardActions actions = GetNonRedundantActions(e); // Raw --> PreviewKeyDown if ((actions & RawKeyboardActions.KeyDown) == RawKeyboardActions.KeyDown) { Key key = (Key)e.StagingItem.GetData(_tagKey); if (key != Key.None) { KeyEventArgs previewKeyDown = new KeyEventArgs(this, keyboardInput.InputSource, keyboardInput.Timestamp, key); ScanCode scanCode = (ScanCode)e.StagingItem.GetData(_tagScanCode); previewKeyDown.ScanCode = scanCode.Code; previewKeyDown.IsExtendedKey = scanCode.IsExtended; if (keyboardInput.IsSystemKey) { previewKeyDown.MarkSystem(); } previewKeyDown.RoutedEvent = Keyboard.PreviewKeyDownEvent; e.PushInput(previewKeyDown, e.StagingItem); } } // Raw --> PreviewKeyUp if ((actions & RawKeyboardActions.KeyUp) == RawKeyboardActions.KeyUp) { Key key = (Key)e.StagingItem.GetData(_tagKey); if (key != Key.None) { KeyEventArgs previewKeyUp = new KeyEventArgs(this, keyboardInput.InputSource, keyboardInput.Timestamp, key); ScanCode scanCode = (ScanCode)e.StagingItem.GetData(_tagScanCode); previewKeyUp.ScanCode = scanCode.Code; previewKeyUp.IsExtendedKey = scanCode.IsExtended; if (keyboardInput.IsSystemKey) { previewKeyUp.MarkSystem(); } previewKeyUp.RoutedEvent = Keyboard.PreviewKeyUpEvent; e.PushInput(previewKeyUp, e.StagingItem); } } } // Deactivate if ((keyboardInput.Actions & RawKeyboardActions.Deactivate) == RawKeyboardActions.Deactivate) { if (IsActive) { _activeSource = null; // Even if handled, a keyboard deactivate results in a lost focus. ChangeFocus(null, e.StagingItem.Input.Timestamp); } } } }
private void PostProcessInput(object sender, ProcessInputEventArgs e) { // KeyUp if (e.StagingItem.Input.RoutedEvent == Keyboard.KeyUpEvent) { KeyEventArgs keyArgs = (KeyEventArgs)e.StagingItem.Input; if (!keyArgs.Handled) { if (keyArgs.RealKey == Key.LeftAlt || keyArgs.RealKey == Key.RightAlt) { // Make sure both Alt keys are up. ModifierKeys modifiers = keyArgs.KeyboardDevice.Modifiers; if ((modifiers & ModifierKeys.Alt) == 0) { if (_altNumpadEntryMode) { _altNumpadEntryMode = false; // Generate the Unicode equivalent if we // actually entered a number via the numpad. if (_altNumpadEntry != 0) { _altNumpadcomposition.ClearTexts(); if (_altNumpadConversionMode == AltNumpadConversionMode.OEMCodePage) { _altNumpadcomposition.SetText(GetCurrentOEMCPEncoding(_altNumpadEntry)); } else if ((_altNumpadConversionMode == AltNumpadConversionMode.DefaultCodePage) || (_altNumpadConversionMode == AltNumpadConversionMode.HexDefaultCodePage)) { _altNumpadcomposition.SetText(CharacterEncoding(InputLanguageManager.Current.CurrentInputLanguage.TextInfo.ANSICodePage, _altNumpadEntry)); } else if (_altNumpadConversionMode == AltNumpadConversionMode.HexUnicode) { Char[] chars = new Char[1]; chars[0] = (Char)_altNumpadEntry; _altNumpadcomposition.SetText(new string(chars)); } } } } } } else { // Someone handled Alt key up event, we cancel Alt-Numpad handling. _altNumpadEntryMode = false; _altNumpadEntry = 0; _altNumpadConversionMode = AltNumpadConversionMode.OEMCodePage; } } // PreviewTextInputBegin --> TextInputStart else if (e.StagingItem.Input.RoutedEvent == TextCompositionManager.PreviewTextInputStartEvent) { TextCompositionEventArgs textArgs = (TextCompositionEventArgs)e.StagingItem.Input; if (!textArgs.Handled) { TextCompositionEventArgs text = new TextCompositionEventArgs(textArgs.Device, textArgs.TextComposition); text.RoutedEvent = TextCompositionManager.TextInputStartEvent; text.Source = textArgs.TextComposition.Source; e.PushInput(text, e.StagingItem); } } // PreviewTextInputUpdate --> TextInputUpdate else if (e.StagingItem.Input.RoutedEvent == TextCompositionManager.PreviewTextInputUpdateEvent) { TextCompositionEventArgs textArgs = (TextCompositionEventArgs)e.StagingItem.Input; if (!textArgs.Handled) { TextCompositionEventArgs text = new TextCompositionEventArgs(textArgs.Device, textArgs.TextComposition); text.RoutedEvent = TextCompositionManager.TextInputUpdateEvent; text.Source = textArgs.TextComposition.Source; e.PushInput(text, e.StagingItem); } } // PreviewTextInput --> TextInput else if (e.StagingItem.Input.RoutedEvent == TextCompositionManager.PreviewTextInputEvent) { TextCompositionEventArgs textArgs = (TextCompositionEventArgs)e.StagingItem.Input; if (!textArgs.Handled) { TextCompositionEventArgs text = new TextCompositionEventArgs(textArgs.Device, textArgs.TextComposition); text.RoutedEvent = TextCompositionManager.TextInputEvent; text.Source = textArgs.TextComposition.Source; e.PushInput(text, e.StagingItem); } } // TextCompositioniBegin --> TextInput if this is AutomaticComplete. else if (e.StagingItem.Input.RoutedEvent == TextCompositionManager.TextInputStartEvent) { TextCompositionEventArgs textArgs = (TextCompositionEventArgs)e.StagingItem.Input; if (!textArgs.Handled) { if (textArgs.TextComposition.AutoComplete == TextCompositionAutoComplete.On) { textArgs.Handled = UnsafeCompleteComposition(textArgs.TextComposition); } } } // TextCompositionUpdate --> TextInput if this is AutomaticComplete. else if (e.StagingItem.Input.RoutedEvent == TextCompositionManager.TextInputUpdateEvent) { TextCompositionEventArgs textArgs = (TextCompositionEventArgs)e.StagingItem.Input; if (!textArgs.Handled) { if ((textArgs.TextComposition == _deadCharTextComposition) && (_deadCharTextComposition.Composed)) { //Clear the _deadCharTextComposition to handle re-entrant cases. DeadCharTextComposition comp = _deadCharTextComposition; _deadCharTextComposition = null; textArgs.Handled = UnsafeCompleteComposition(comp); } } } // Raw to StartComposition. InputReportEventArgs input = e.StagingItem.Input as InputReportEventArgs; if (input != null) { if (input.Report.Type == InputType.Text && input.RoutedEvent == InputManager.InputReportEvent) { RawTextInputReport textInput; textInput = (RawTextInputReport)input.Report; // // string inputText = new string(textInput.CharacterCode, 1); bool fDoneAltNumpadComposition = false; if (_altNumpadcomposition != null) { // Generate TextInput event from WM_CHAR handler. if (inputText.Equals(_altNumpadcomposition.Text)) { fDoneAltNumpadComposition = true; } else { // The generated text from InputReport does not matched with _altNumpadcomposition. // Cancel this composition and process the char from InputReport. _altNumpadcomposition.ClearTexts(); } _altNumpadcomposition.Complete(); ClearAltnumpadComposition(); } if (!fDoneAltNumpadComposition) { if (textInput.IsDeadCharacter) { _deadCharTextComposition = new DeadCharTextComposition(_inputManager, (IInputElement)null, inputText, TextCompositionAutoComplete.Off, InputManager.Current.PrimaryKeyboardDevice); if (textInput.IsSystemCharacter) { _deadCharTextComposition.MakeSystem(); } else if (textInput.IsControlCharacter) { _deadCharTextComposition.MakeControl(); } input.Handled = UnsafeStartComposition(_deadCharTextComposition); } else { if (_deadCharTextComposition != null) { input.Handled = CompleteDeadCharComposition(inputText, textInput.IsSystemCharacter, textInput.IsControlCharacter); } else { TextComposition composition = new TextComposition(_inputManager, (IInputElement)e.StagingItem.Input.Source, inputText, TextCompositionAutoComplete.On, InputManager.Current.PrimaryKeyboardDevice); if (textInput.IsSystemCharacter) { composition.MakeSystem(); } else if (textInput.IsControlCharacter) { composition.MakeControl(); } input.Handled = UnsafeStartComposition(composition); } } } } } }
private void PostProcessInput(object sender, ProcessInputEventArgs e) { // KeyUp if(e.StagingItem.Input.RoutedEvent == Keyboard.KeyUpEvent) { KeyEventArgs keyArgs = (KeyEventArgs) e.StagingItem.Input; if(!keyArgs.Handled) { if(keyArgs.RealKey == Key.LeftAlt || keyArgs.RealKey == Key.RightAlt) { // Make sure both Alt keys are up. ModifierKeys modifiers = keyArgs.KeyboardDevice.Modifiers; if((modifiers & ModifierKeys.Alt) == 0) { if(_altNumpadEntryMode) { _altNumpadEntryMode = false; // Generate the Unicode equivalent if we // actually entered a number via the numpad. if(_altNumpadEntry != 0) { _altNumpadcomposition.ClearTexts(); if (_altNumpadConversionMode == AltNumpadConversionMode.OEMCodePage) { _altNumpadcomposition.SetText(GetCurrentOEMCPEncoding(_altNumpadEntry)); } else if ((_altNumpadConversionMode == AltNumpadConversionMode.DefaultCodePage) || (_altNumpadConversionMode == AltNumpadConversionMode.HexDefaultCodePage)) { _altNumpadcomposition.SetText(CharacterEncoding(InputLanguageManager.Current.CurrentInputLanguage.TextInfo.ANSICodePage, _altNumpadEntry)); } else if (_altNumpadConversionMode == AltNumpadConversionMode.HexUnicode) { Char[] chars = new Char[1]; chars[0] = (Char) _altNumpadEntry; _altNumpadcomposition.SetText(new string(chars)); } } } } } } else { // Someone handled Alt key up event, we cancel Alt-Numpad handling. _altNumpadEntryMode = false; _altNumpadEntry = 0; _altNumpadConversionMode = AltNumpadConversionMode.OEMCodePage; } } // PreviewTextInputBegin --> TextInputStart else if(e.StagingItem.Input.RoutedEvent == TextCompositionManager.PreviewTextInputStartEvent) { TextCompositionEventArgs textArgs = (TextCompositionEventArgs) e.StagingItem.Input; if(!textArgs.Handled) { TextCompositionEventArgs text = new TextCompositionEventArgs(textArgs.Device, textArgs.TextComposition); text.RoutedEvent=TextCompositionManager.TextInputStartEvent; text.Source= textArgs.TextComposition.Source; e.PushInput(text, e.StagingItem); } } // PreviewTextInputUpdate --> TextInputUpdate else if(e.StagingItem.Input.RoutedEvent == TextCompositionManager.PreviewTextInputUpdateEvent) { TextCompositionEventArgs textArgs = (TextCompositionEventArgs) e.StagingItem.Input; if(!textArgs.Handled) { TextCompositionEventArgs text = new TextCompositionEventArgs(textArgs.Device, textArgs.TextComposition); text.RoutedEvent=TextCompositionManager.TextInputUpdateEvent; text.Source= textArgs.TextComposition.Source; e.PushInput(text, e.StagingItem); } } // PreviewTextInput --> TextInput else if(e.StagingItem.Input.RoutedEvent == TextCompositionManager.PreviewTextInputEvent) { TextCompositionEventArgs textArgs = (TextCompositionEventArgs) e.StagingItem.Input; if(!textArgs.Handled) { TextCompositionEventArgs text = new TextCompositionEventArgs(textArgs.Device, textArgs.TextComposition); text.RoutedEvent=TextCompositionManager.TextInputEvent; text.Source= textArgs.TextComposition.Source; e.PushInput(text, e.StagingItem); } } // TextCompositioniBegin --> TextInput if this is AutomaticComplete. else if(e.StagingItem.Input.RoutedEvent == TextCompositionManager.TextInputStartEvent) { TextCompositionEventArgs textArgs = (TextCompositionEventArgs) e.StagingItem.Input; if(!textArgs.Handled) { if (textArgs.TextComposition.AutoComplete == TextCompositionAutoComplete.On) { textArgs.Handled = UnsafeCompleteComposition(textArgs.TextComposition); } } } // TextCompositionUpdate --> TextInput if this is AutomaticComplete. else if(e.StagingItem.Input.RoutedEvent == TextCompositionManager.TextInputUpdateEvent) { TextCompositionEventArgs textArgs = (TextCompositionEventArgs) e.StagingItem.Input; if(!textArgs.Handled) { if ((textArgs.TextComposition == _deadCharTextComposition) && (_deadCharTextComposition.Composed)) { //Clear the _deadCharTextComposition to handle re-entrant cases. DeadCharTextComposition comp = _deadCharTextComposition; _deadCharTextComposition = null; textArgs.Handled = UnsafeCompleteComposition(comp); } } } // Raw to StartComposition. InputReportEventArgs input = e.StagingItem.Input as InputReportEventArgs; if(input != null) { if(input.Report.Type == InputType.Text && input.RoutedEvent == InputManager.InputReportEvent) { RawTextInputReport textInput; textInput = (RawTextInputReport)input.Report; // // string inputText = new string(textInput.CharacterCode, 1); bool fDoneAltNumpadComposition = false; if (_altNumpadcomposition != null) { // Generate TextInput event from WM_CHAR handler. if (inputText.Equals(_altNumpadcomposition.Text)) { fDoneAltNumpadComposition = true; } else { // The generated text from InputReport does not matched with _altNumpadcomposition. // Cancel this composition and process the char from InputReport. _altNumpadcomposition.ClearTexts(); } _altNumpadcomposition.Complete(); ClearAltnumpadComposition(); } if (!fDoneAltNumpadComposition) { if (textInput.IsDeadCharacter) { _deadCharTextComposition = new DeadCharTextComposition(_inputManager, (IInputElement)null, inputText , TextCompositionAutoComplete.Off, InputManager.Current.PrimaryKeyboardDevice); if (textInput.IsSystemCharacter) { _deadCharTextComposition.MakeSystem(); } else if (textInput.IsControlCharacter) { _deadCharTextComposition.MakeControl(); } input.Handled = UnsafeStartComposition(_deadCharTextComposition); } else { if(inputText != null) { if (_deadCharTextComposition != null) { _deadCharTextComposition.ClearTexts(); _deadCharTextComposition.SetText(inputText); _deadCharTextComposition.Composed = true; if (textInput.IsSystemCharacter) { _deadCharTextComposition.MakeSystem(); } else if (textInput.IsControlCharacter) { _deadCharTextComposition.MakeControl(); } input.Handled = UnsafeUpdateComposition(_deadCharTextComposition); } else { TextComposition composition = new TextComposition(_inputManager, (IInputElement)e.StagingItem.Input.Source, inputText, TextCompositionAutoComplete.On, InputManager.Current.PrimaryKeyboardDevice); if (textInput.IsSystemCharacter) { composition.MakeSystem(); } else if (textInput.IsControlCharacter) { composition.MakeControl(); } input.Handled = UnsafeStartComposition(composition); } } } } } } }
private void PostProcessInput(object sender, ProcessInputEventArgs e) { // PreviewMouseWheel --> MouseWheel if (e.StagingItem.Input.RoutedEvent == Mouse.PreviewMouseWheelEvent) { if (!e.StagingItem.Input.Handled) { MouseWheelEventArgs previewWheel = (MouseWheelEventArgs) e.StagingItem.Input; MouseWheelEventArgs wheel = new MouseWheelEventArgs(this, previewWheel.Timestamp, previewWheel.Delta); wheel.RoutedEvent=Mouse.MouseWheelEvent; #if SEND_WHEEL_EVENTS_TO_FOCUS // wheel events are treated as if they came from the // element with keyboard focus wheel.Source = previewWheel.Source; #endif e.PushInput(wheel, e.StagingItem); } } // PreviewMouseDown --> MouseDown if (e.StagingItem.Input.RoutedEvent == Mouse.PreviewMouseDownEvent) { if (!e.StagingItem.Input.Handled) { MouseButtonEventArgs previewDown = (MouseButtonEventArgs) e.StagingItem.Input; MouseButtonEventArgs down = new MouseButtonEventArgs(this, previewDown.Timestamp, previewDown.ChangedButton, GetStylusDevice(e.StagingItem)); down.ClickCount = previewDown.ClickCount; down.RoutedEvent=Mouse.MouseDownEvent; e.PushInput(down, e.StagingItem); } } // PreviewMouseUp --> MouseUp if (e.StagingItem.Input.RoutedEvent == Mouse.PreviewMouseUpEvent) { if (!e.StagingItem.Input.Handled) { MouseButtonEventArgs previewUp = (MouseButtonEventArgs) e.StagingItem.Input; MouseButtonEventArgs up = new MouseButtonEventArgs(this, previewUp.Timestamp, previewUp.ChangedButton, GetStylusDevice(e.StagingItem)); up.RoutedEvent=Mouse.MouseUpEvent; e.PushInput(up, e.StagingItem); } } // PreviewMouseMove --> MouseMove if (e.StagingItem.Input.RoutedEvent == Mouse.PreviewMouseMoveEvent) { if (!e.StagingItem.Input.Handled) { MouseEventArgs previewMove = (MouseEventArgs) e.StagingItem.Input; MouseEventArgs move = new MouseEventArgs(this, previewMove.Timestamp, GetStylusDevice(e.StagingItem)); move.RoutedEvent=Mouse.MouseMoveEvent; e.PushInput(move, e.StagingItem); } } // We are finished processing the QueryCursor event. Just update the // mouse cursor to be what was decided during the event route. if (e.StagingItem.Input.RoutedEvent == Mouse.QueryCursorEvent) { QueryCursorEventArgs queryCursor = (QueryCursorEventArgs)e.StagingItem.Input; SetCursor(queryCursor.Cursor); } if (e.StagingItem.Input.RoutedEvent == InputManager.InputReportEvent) { InputReportEventArgs inputReportEventArgs = e.StagingItem.Input as InputReportEventArgs; if (!inputReportEventArgs.Handled && inputReportEventArgs.Report.Type == InputType.Mouse) { RawMouseInputReport rawMouseInputReport = (RawMouseInputReport) inputReportEventArgs.Report; // Only process mouse input that is from our active visual manager. if ((_inputSource != null) && (rawMouseInputReport.InputSource == _inputSource.Value)) { // In general, this is where we promote the non-redundant // reported actions to our premier events. RawMouseActions actions = GetNonRedundantActions(e); // Raw Activate --> Raw MouseMove // Whenever the mouse device is activated we need to // cause a mouse move so that elements realize that // the mouse is over them again. In most cases, the // action that caused the mouse to activate is a move, // but this is to guard against any other cases. if ((actions & RawMouseActions.Activate) == RawMouseActions.Activate) { Synchronize(); } // Raw --> PreviewMouseWheel if ((actions & RawMouseActions.VerticalWheelRotate) == RawMouseActions.VerticalWheelRotate) // { MouseWheelEventArgs previewWheel = new MouseWheelEventArgs(this, rawMouseInputReport.Timestamp, rawMouseInputReport.Wheel); previewWheel.RoutedEvent=Mouse.PreviewMouseWheelEvent; #if SEND_WHEEL_EVENTS_TO_FOCUS // wheel events are treated as if they came from the // element with keyboard focus DependencyObject focus = Keyboard.FocusedElement as DependencyObject; if (focus != null) { previewWheel.Source = focus; } #endif e.PushInput(previewWheel, e.StagingItem); } // Raw --> PreviewMouseDown if ((actions & RawMouseActions.Button1Press) == RawMouseActions.Button1Press) { MouseButtonEventArgs previewDown = new MouseButtonEventArgs(this, rawMouseInputReport.Timestamp, MouseButton.Left, GetStylusDevice(e.StagingItem)); previewDown.RoutedEvent=Mouse.PreviewMouseDownEvent; e.PushInput(previewDown, e.StagingItem); } // Raw --> PreviewMouseUp if ((actions & RawMouseActions.Button1Release) == RawMouseActions.Button1Release) { MouseButtonEventArgs previewUp = new MouseButtonEventArgs(this, rawMouseInputReport.Timestamp, MouseButton.Left, GetStylusDevice(e.StagingItem)); previewUp.RoutedEvent=Mouse.PreviewMouseUpEvent; e.PushInput(previewUp, e.StagingItem); } // Raw --> PreviewMouseDown if ((actions & RawMouseActions.Button2Press) == RawMouseActions.Button2Press) { MouseButtonEventArgs previewDown = new MouseButtonEventArgs(this, rawMouseInputReport.Timestamp, MouseButton.Right, GetStylusDevice(e.StagingItem)); previewDown.RoutedEvent=Mouse.PreviewMouseDownEvent; e.PushInput(previewDown, e.StagingItem); } // Raw --> PreviewMouseUp if ((actions & RawMouseActions.Button2Release) == RawMouseActions.Button2Release) { MouseButtonEventArgs previewUp = new MouseButtonEventArgs(this, rawMouseInputReport.Timestamp, MouseButton.Right, GetStylusDevice(e.StagingItem)); previewUp.RoutedEvent=Mouse.PreviewMouseUpEvent; e.PushInput(previewUp, e.StagingItem); } // Raw --> PreviewMouseDown if ((actions & RawMouseActions.Button3Press) == RawMouseActions.Button3Press) { MouseButtonEventArgs previewDown = new MouseButtonEventArgs(this, rawMouseInputReport.Timestamp, MouseButton.Middle, GetStylusDevice(e.StagingItem)); previewDown.RoutedEvent=Mouse.PreviewMouseDownEvent; e.PushInput(previewDown, e.StagingItem); } // Raw --> PreviewMouseUp if ((actions & RawMouseActions.Button3Release) == RawMouseActions.Button3Release) { MouseButtonEventArgs previewUp = new MouseButtonEventArgs(this, rawMouseInputReport.Timestamp, MouseButton.Middle, GetStylusDevice(e.StagingItem)); previewUp.RoutedEvent=Mouse.PreviewMouseUpEvent; e.PushInput(previewUp, e.StagingItem); } // Raw --> PreviewMouseDown if ((actions & RawMouseActions.Button4Press) == RawMouseActions.Button4Press) { MouseButtonEventArgs previewDown = new MouseButtonEventArgs(this, rawMouseInputReport.Timestamp, MouseButton.XButton1, GetStylusDevice(e.StagingItem)); previewDown.RoutedEvent=Mouse.PreviewMouseDownEvent; e.PushInput(previewDown, e.StagingItem); } // Raw --> PreviewMouseUp if ((actions & RawMouseActions.Button4Release) == RawMouseActions.Button4Release) { MouseButtonEventArgs previewUp = new MouseButtonEventArgs(this, rawMouseInputReport.Timestamp, MouseButton.XButton1, GetStylusDevice(e.StagingItem)); previewUp.RoutedEvent=Mouse.PreviewMouseUpEvent; e.PushInput(previewUp, e.StagingItem); } // Raw --> PreviewMouseDown if ((actions & RawMouseActions.Button5Press) == RawMouseActions.Button5Press) { MouseButtonEventArgs previewDown = new MouseButtonEventArgs(this, rawMouseInputReport.Timestamp, MouseButton.XButton2, GetStylusDevice(e.StagingItem)); previewDown.RoutedEvent=Mouse.PreviewMouseDownEvent; e.PushInput(previewDown, e.StagingItem); } // Raw --> PreviewMouseUp if ((actions & RawMouseActions.Button5Release) == RawMouseActions.Button5Release) { MouseButtonEventArgs previewUp = new MouseButtonEventArgs(this, rawMouseInputReport.Timestamp, MouseButton.XButton2, GetStylusDevice(e.StagingItem)); previewUp.RoutedEvent=Mouse.PreviewMouseUpEvent; e.PushInput(previewUp, e.StagingItem); } // Raw --> PreviewMouseMove if ((actions & RawMouseActions.AbsoluteMove) == RawMouseActions.AbsoluteMove) // { MouseEventArgs previewMove = new MouseEventArgs(this, rawMouseInputReport.Timestamp, GetStylusDevice(e.StagingItem)); previewMove.RoutedEvent=Mouse.PreviewMouseMoveEvent; e.PushInput(previewMove, e.StagingItem); } // Raw --> QueryCursor if ((actions & RawMouseActions.QueryCursor) == RawMouseActions.QueryCursor) { inputReportEventArgs.Handled = UpdateCursorPrivate(); } } } } }
private void PostProcessInput( object sender, ProcessInputEventArgs e ) { if (e.StagingItem.Input.RoutedEvent == InputManager.InputReportEvent) { if (!e.StagingItem.Input.Handled) { InputReportEventArgs inputReportEventArgs = e.StagingItem.Input as InputReportEventArgs; if (inputReportEventArgs != null) { RawAppCommandInputReport rawAppCommandInputReport = inputReportEventArgs.Report as RawAppCommandInputReport; if (rawAppCommandInputReport != null) { IInputElement commandTarget = e.StagingItem.Input.OriginalSource as IInputElement; if (commandTarget != null) { RoutedCommand command = GetRoutedCommand(rawAppCommandInputReport.AppCommand); if (command != null) { // Send the app command to the tree to be handled by UIElements and ContentElements // that will forward the event to CommandManager. CommandDeviceEventArgs args = new CommandDeviceEventArgs(this, rawAppCommandInputReport.Timestamp, command); args.RoutedEvent = CommandDeviceEvent; args.Source = commandTarget; e.PushInput(args, e.StagingItem); } } } } } } else if (e.StagingItem.Input.RoutedEvent == Keyboard.KeyUpEvent || e.StagingItem.Input.RoutedEvent == Mouse.MouseUpEvent || e.StagingItem.Input.RoutedEvent == Keyboard.GotKeyboardFocusEvent || e.StagingItem.Input.RoutedEvent == Keyboard.LostKeyboardFocusEvent) { CommandManager.InvalidateRequerySuggested(); } }
static void PromotePreviewToMain(ProcessInputEventArgs e, InputEventArgs input) { ContactEventArgs previewArgs = (ContactEventArgs)input; RoutedEvent mainEvent = GetMainEventFromPreviewEvent(input.RoutedEvent); if (mainEvent != null) { ContactEventArgs mainArgs; if (mainEvent == MultitouchScreen.NewContactEvent || mainEvent == MultitouchScreen.PreviewNewContactEvent) { NewContactEventArgs newContactEventArgs = (NewContactEventArgs)previewArgs; mainArgs = new NewContactEventArgs(newContactEventArgs.Contact, previewArgs.Timestamp); } else mainArgs = new ContactEventArgs(previewArgs.Contact, previewArgs.Timestamp); mainArgs.RoutedEvent = mainEvent; mainArgs.Source = previewArgs.Source; e.PushInput(mainArgs, e.StagingItem); } }
void PromoteRawToPreview(ProcessInputEventArgs e, RawMultitouchReport report) { ContactContext context = report.Context; RoutedEvent routedEvent = GetPreviewEventFromRawMultitouchState(context.Contact.State); if (report.Context.OverElement != null && routedEvent != null) { Contact contact = ContactsManager.ExistingContacts[report.Context.Contact.Id]; ContactEventArgs args; if (routedEvent == MultitouchScreen.PreviewNewContactEvent) args = new NewContactEventArgs(contact, report.Timestamp); else args = new ContactEventArgs(contact, report.Timestamp); args.RoutedEvent = routedEvent; args.Source = report.Context.OverElement; e.PushInput(args, e.StagingItem); } }
void inputManager_PostProcessInput(object sender, ProcessInputEventArgs e) { InputEventArgs input = e.StagingItem.Input; if (input.RoutedEvent == PreviewRawInputEvent && !input.Handled) PromoteRawToPreview(e, (RawMultitouchReport)input); else if (input.Device != null && input.Device.GetType() == contactType) { if (!input.Handled) PromotePreviewToMain(e, input); if (input.RoutedEvent == MultitouchScreen.ContactRemovedEvent) { ContactEventArgs args = (ContactEventArgs)input; RawMultitouchReport report = args.Contact.InputArgs.Clone(); report.CleanUp = true; e.PushInput(report, e.StagingItem); } } }
void PromotePreviewToMain(ProcessInputEventArgs e) { if (!e.StagingItem.Input.Handled) { RoutedEvent eventMain = GetMainEventFromPreviewEvent(e.StagingItem.Input.RoutedEvent); if (eventMain != null) { StylusEventArgs eventArgsPreview = (StylusEventArgs)e.StagingItem.Input; StylusDevice stylusDevice = eventArgsPreview.InputReport.StylusDevice; StylusEventArgs eventArgsMain; if (eventMain == Stylus.StylusDownEvent || eventMain == Stylus.PreviewStylusDownEvent) { StylusDownEventArgs downEventArgsPreview = (StylusDownEventArgs)eventArgsPreview; eventArgsMain = new StylusDownEventArgs(stylusDevice, eventArgsPreview.Timestamp); } else if (eventMain == Stylus.StylusButtonDownEvent || eventMain == Stylus.StylusButtonUpEvent) { StylusButtonEventArgs buttonEventArgsPreview = (StylusButtonEventArgs)eventArgsPreview; eventArgsMain = new StylusButtonEventArgs(stylusDevice, eventArgsPreview.Timestamp, buttonEventArgsPreview.StylusButton); } else if (eventMain != Stylus.StylusSystemGestureEvent) { eventArgsMain = new StylusEventArgs(stylusDevice, eventArgsPreview.Timestamp); } else { StylusSystemGestureEventArgs previewSystemGesture = (StylusSystemGestureEventArgs)eventArgsPreview; eventArgsMain = new StylusSystemGestureEventArgs(stylusDevice, previewSystemGesture.Timestamp, previewSystemGesture.SystemGesture, previewSystemGesture.GestureX, previewSystemGesture.GestureY, previewSystemGesture.ButtonState); } eventArgsMain.InputReport = eventArgsPreview.InputReport; eventArgsMain.RoutedEvent = eventMain; e.PushInput(eventArgsMain, e.StagingItem); } } else { // A TouchDevice is activated before TouchDown and deactivated after TouchUp // But if PreviewStylusUp event is handled by the user, it will // never be promoted to TouchUp event leaving the TouchDevice in inconsistent // active state. Hence deactivating touch device if it is active. StylusEventArgs stylusEventArgs = e.StagingItem.Input as StylusEventArgs; if (stylusEventArgs != null && stylusEventArgs.RoutedEvent == Stylus.PreviewStylusUpEvent && stylusEventArgs.StylusDevice.TouchDevice.IsActive) { stylusEventArgs.StylusDevice.TouchDevice.OnDeactivate(); } } }
void PromoteRawToPreview(RawStylusInputReport report, ProcessInputEventArgs e) { RoutedEvent routedEvent = GetPreviewEventFromRawStylusActions(report.Actions); if (routedEvent != null && report.StylusDevice != null && !report.StylusDevice.IgnoreStroke) { StylusEventArgs args; if (routedEvent != Stylus.PreviewStylusSystemGestureEvent) { if (routedEvent == Stylus.PreviewStylusDownEvent) { args = new StylusDownEventArgs(report.StylusDevice, report.Timestamp); } else { args = new StylusEventArgs(report.StylusDevice, report.Timestamp); } } else { RawStylusSystemGestureInputReport reportSg = (RawStylusSystemGestureInputReport)report; args = new StylusSystemGestureEventArgs(report.StylusDevice, report.Timestamp, reportSg.SystemGesture, reportSg.GestureX, reportSg.GestureY, reportSg.ButtonState); } args.InputReport = report; args.RoutedEvent= routedEvent; e.PushInput(args, e.StagingItem); } }