public virtual IntPtr KeyboardActivity(Object sender, KeyboardActivityArgs kbda) { if (null != KeyboardActivityEvent) KeyboardActivityEvent(this, kbda); return new IntPtr(1); }
public override void OnKeyUp(KeyboardActivityArgs ke) { switch (ke.VirtualKeyCode) { case VirtualKeyCodes.Escape: this.Destroy(); break; } }
public virtual void ReceiveChunk(BufferChunk aRecord) { // First read out the record type int recordType = aRecord.NextInt32(); // Then deserialize the rest from there switch ((UserIOCommand)recordType) { case UserIOCommand.HideCursor: HideCursor(); break; case UserIOCommand.Showcursor: ShowCursor(); break; case UserIOCommand.MoveCursor: { int x = aRecord.NextInt32(); int y = aRecord.NextInt32(); MoveCursor(x, y); } break; case UserIOCommand.KeyboardActivity: { KeyActivityType kEvent = (KeyActivityType)aRecord.NextInt32(); VirtualKeyCodes vk = (VirtualKeyCodes)aRecord.NextInt32(); KeyboardActivityArgs kbda = new KeyboardActivityArgs(kEvent, vk); KeyboardActivity(this, kbda); } break; case UserIOCommand.MouseActivity: { MouseActivityType maType = MouseActivityType.None; MouseButtonActivity mbActivity = (MouseButtonActivity)aRecord.NextInt32(); int x = aRecord.NextInt32(); int y = aRecord.NextInt32(); int clicks = aRecord.NextInt32(); short delta = aRecord.NextInt16(); int keyflags = 0; MouseActivityArgs ma = new MouseActivityArgs(null, maType, mbActivity, MouseCoordinateSpace.Desktop, MouseMovementType.Absolute, IntPtr.Zero, x, y, delta, clicks, keyflags); MouseActivity(this, ma); } break; default: break; } }
public override IntPtr OnKeyboardActivity(object sender, KeyboardActivityArgs kbde) { if (kbde.AcitivityType == KeyActivityType.KeyUp) { switch (kbde.VirtualKeyCode) { case VirtualKeyCodes.T: leftFirst = !leftFirst; break; } } return IntPtr.Zero; }
public override void OnKeyboardActivity(object sender, KeyboardActivityArgs kbde) { base.OnKeyboardActivity(sender, kbde); if (kbde.EventType == KeyEventType.KeyUp) { switch (kbde.VirtualKeyCode) { } } switch (kbde.VirtualKeyCode) { } }
public override IntPtr OnKeyboardActivity(object sender, KeyboardActivityArgs kbde) { if (kbde.AcitivityType == KeyActivityType.KeyUp) { switch (kbde.VirtualKeyCode) { case VirtualKeyCodes.Space: fDemoCounter++; if (fDemoCounter >= fDemos.Count) fDemoCounter = 0; RenderFrame(); break; } } return IntPtr.Zero; }
public override void OnKeyDown(KeyboardActivityArgs ke) { switch (ke.VirtualKeyCode) { case VirtualKeyCodes.Space: fCamera.GrabSingleFrame(); break; case VirtualKeyCodes.C: fCamera.ShowCompressionChoices(); break; case VirtualKeyCodes.F: fCamera.ShowVideoFormats(); break; case VirtualKeyCodes.S: fCamera.ShowVideoSourceChoices(); break; } }
public override IntPtr OnKeyboardActivity(object sender, KeyboardActivityArgs kbda) { switch (kbda.AcitivityType) { // Only send down/up, not the keychar or we'll get doubles case KeyActivityType.KeyDown: case KeyActivityType.KeyUp: case KeyActivityType.SysKeyDown: case KeyActivityType.SysKeyUp: fUserIOEncoder.KeyboardActivity(sender, kbda); break; default: //base.OnKeyboardActivity(sender, kbda); break; } return IntPtr.Zero; }
public override IntPtr OnKeyUp(KeyboardActivityArgs ke) { switch (ke.VirtualKeyCode) { case VirtualKeyCodes.S: fAutoScale = !fAutoScale; Invalidate(); break; } return base.OnKeyUp(ke); }
public static KeyboardActivityArgs CreateFromKeyboardHookProc(IntPtr wParam, IntPtr lParam) { IntPtr windowHandle = IntPtr.Zero; VirtualKeyCodes virtualKey = (VirtualKeyCodes)wParam.ToInt32(); KeyActivityType kEType = KeyActivityType.None; ulong keyFlags = (ulong)lParam; Char aChar = '\0'; // The keyflags are decoded in the following way // bits 0 - 15 Repeat count // bits 16 - 23 scan code (OEM Specific) // bit 24 Whether the key is an extended key // bits 25 - 28 Reserved, do not use // bit 29 Context code. Zero for key down // bit 30 Specifies previous key state. // The value is 1 if the key is down before the message is sent, or it is zero if the key is up. // bit 31 Specifies the transition state. int repeatCount = (int)keyFlags & 0xffff; int scanCode = ((int)keyFlags & 0xff0000) >> 16; bool isExtended = (((int)keyFlags & 0x1000000) >> 24) == 1; int context = ((int)keyFlags & 0x20000000) >> 29; bool altPressed = (1 == context); uint transition = ((uint)keyFlags & 0x80000000) >> 31; if (0 == transition) kEType = KeyActivityType.KeyDown; else kEType = KeyActivityType.KeyUp; KeyboardActivityArgs ke = new KeyboardActivityArgs(null, windowHandle, kEType, virtualKey, KeyMasks.None, scanCode, repeatCount, isExtended, aChar); return ke; }
public override IntPtr OnKeyboardActivity(object sender, KeyboardActivityArgs kbde) { base.OnKeyboardActivity(sender, kbde); if (kbde.AcitivityType == KeyActivityType.KeyDown) { switch (kbde.VirtualKeyCode) { // Move closer to current direction case VirtualKeyCodes.Up: fCameraLocation.z += 0.5f; fExpansionFactor *= fExpansionRatio; if (fExpansionFactor > 2.0) fExpansionFactor = 2.0f; break; // Move further from center case VirtualKeyCodes.Down: fCameraLocation.z -= 0.5f; fExpansionFactor *= 1 / fExpansionRatio; if (fExpansionFactor < 1.0f) fExpansionFactor = 1.0f; break; // Look to the right case VirtualKeyCodes.Right: if (!kbde.Shift) fCameraRotation.y += 10; else fCameraLocation.x += 0.5f; break; // Look to the left case VirtualKeyCodes.Left: if (!kbde.Shift) fCameraRotation.y -= 10; else fCameraLocation.x -= 0.5f; break; case VirtualKeyCodes.PageUp: fCameraLocation.y -= 0.5f; break; case VirtualKeyCodes.PageDown: fCameraLocation.y += 0.5f; break; default: break; } } return IntPtr.Zero; }
public override void OnKeyUp(KeyboardActivityArgs ke) { int min = int.MinValue; int max = int.MaxValue; int step = 0; int defaultValue = 0; int currentValue = 0; CameraControlFlags camFlags = CameraControlFlags.None; IAMCameraControl camControl = m_CaptureDevice.GetCameraControl(); switch (ke.VirtualKeyCode) { case VirtualKeyCodes.S: fUseScaling = !fUseScaling; break; case VirtualKeyCodes.R: ResetCamera(); break; case VirtualKeyCodes.Home: m_CamControl.PanToAbsolute(0.0f); break; case VirtualKeyCodes.End: m_CamControl.PanToAbsolute(1.0f); break; } //return IntPtr.Zero; }
public override void OnKeyPress(KeyboardActivityArgs ke) { //Console.Write("{0}", ke.Character); // Deal with characters that are not mode dependent switch (ke.Character) { case '\b': // Backspace // Delete the character that is one position less than // the current character position if (fCharacterPosition == fCurrentTextRun.IndexOfFirstCharacter) return; fCharacterPosition--; fCurrentTextRun.DeleteCharacter(fCharacterPosition); SelectCharacterPosition(fCharacterPosition); //fCaretPosition = fCurrentTextRun.GetTrailingPositionOfIndexedCharacter(fCharacterPosition - 1); //Win32Caret.Current.MoveTo(fCaretPosition.X, fCaretPosition.Y); Invalidate(); return; case '\r': // Return fCaretPosition.Y += fFontSize.Height; fCaretPosition.X = fCaretStartPosition.X; Win32Caret.Current.MoveTo(fCaretPosition.X, fCaretPosition.Y); return; } if (EditMode.Insert == fEditMode) { switch (ke.Character) { default: { fCurrentTextRun.InsertCharacter(fCharacterPosition, ke.Character); SelectCharacterPosition(fCharacterPosition + 1); Invalidate(); } break; } } if (EditMode.Overwrite == fEditMode) { switch (ke.Character) { default: { // Delete the character at the current position DeleteNextCharacter(); // Then insert the new character at the same position // and advance. fCurrentTextRun.InsertCharacter(fCharacterPosition, ke.Character); fCaretPosition = fCurrentTextRun.GetTrailingPositionOfIndexedCharacter(fCharacterPosition); Win32Caret.Current.MoveTo(fCaretPosition.X, fCaretPosition.Y); fCharacterPosition++; Invalidate(); } break; } } }
private void DisplayBinary(KeyboardActivityArgs ke) { int i, j; //int keycode = (int)ke.VirtualKeyCode; int binarycode = (int)ke.ScanCode; uint keymask; // Store bits for lParam in TextStr0[] i = 0; // counter for keystroke bits j = 0; // offset into string keymask = 0x80000000;// bitmask for (i = 0; i < 32; i++) { // Test for separators and skip if (i == 8 || i == 16 || i == 24) { BuffStr0[j] = (char)0x20; j++; } // Test for 1 and 0 bits and display digits if ((binarycode & keymask) > 0) BuffStr0[j] = '1'; else BuffStr0[j] = '0'; keymask = keymask >> 1; j++; } }
private void DisplaySpecialsPressed(KeyboardActivityArgs ke) { int i=0; int j = 0; int keycode = (int)ke.VirtualKeyCode; ushort keycodeonly = (ushort)(keycode & 0xff); if ((keycodeonly & (int)VirtualKeyCodes.Back) == keycodeonly) BuffStr3[15] = 'Y'; else BuffStr3[15] = 'N'; // Test for shift key pressed if (ke.Shift) { i = 0; // counter j = 13; // string offset for (i = 0; i < 3; i++) { BuffStr4[j] = StrON[i]; j++; } } else { i = 0; // counter j = 13; // string offset for (i = 0; i < 3; i++) { BuffStr4[j] = StrOFF[i]; j++; } } }
public override void OnKeyPress(KeyboardActivityArgs ke) { if (null != ActiveGraphic) ActiveGraphic.OnKeyPress(ke); else base.OnKeyPress(ke); }
public override IntPtr OnKeyboardActivity(object sender, KeyboardActivityArgs kbde) { if (kbde.AcitivityType == KeyActivityType.KeyUp) { switch (kbde.VirtualKeyCode) { case VirtualKeyCodes.Space: useShader = !useShader; break; case VirtualKeyCodes.Left: Rotation -= rotationIncrement; break; case VirtualKeyCodes.Right: Rotation += rotationIncrement; break; case VirtualKeyCodes.Up: fHowManySplits += 1; break; case VirtualKeyCodes.Down: fHowManySplits -= 1; if (fHowManySplits < 1) fHowManySplits = 1; break; } } switch (kbde.VirtualKeyCode) { case VirtualKeyCodes.PageUp: fHowManySplits += 1; break; case VirtualKeyCodes.PageDown: fHowManySplits -= 1; if (fHowManySplits < 1) fHowManySplits = 1; break; } return IntPtr.Zero; }
public virtual void OnKeyPress(KeyboardActivityArgs kpe) { }
public virtual void OnKeyUp(KeyboardActivityArgs ke) { }
public virtual void OnNext(KeyboardActivityArgs ke) { switch (ke.AcitivityType) { case KeyActivityType.KeyDown: OnKeyDown(ke); break; case KeyActivityType.KeyUp: OnKeyUp(ke); break; case KeyActivityType.KeyChar: OnKeyPress(ke); break; } }
public override IntPtr OnKeyUp(KeyboardActivityArgs ke) { switch (ke.VirtualKeyCode) { // Switch color on and off case VirtualKeyCodes.G: fUseGray = !fUseGray; break; //case VirtualKeyCodes.I: // fAllowRemoteControl = !fAllowRemoteControl; // break; } return base.OnKeyUp(ke); }
public override IntPtr OnKeyboardActivity(object sender, KeyboardActivityArgs kbde) { if (kbde.AcitivityType == KeyActivityType.KeyUp) { switch (kbde.VirtualKeyCode) { case VirtualKeyCodes.R: fUseRed = !fUseRed; break; case VirtualKeyCodes.G: fUseGreen = !fUseGreen; break; case VirtualKeyCodes.B: fUseBlue = !fUseBlue; break; // Zoom into pixels to fill the window case VirtualKeyCodes.Z: fFillWindow = !fFillWindow; break; // Change what's rendered case VirtualKeyCodes.Space: fRenderMode += 1; if (fRenderMode > lastmode) fRenderMode = 1; break; case VirtualKeyCodes.PrintScreen: // Print Screen break; } } return IntPtr.Zero; }
public override void OnKeyDown(KeyboardActivityArgs ke) { int min = int.MinValue; int max = int.MaxValue; int step = 0; int defaultValue = 0; int currentValue = 0; CameraControlFlags camFlags = CameraControlFlags.None; IAMCameraControl camControl = m_CaptureDevice.GetCameraControl(); switch (ke.VirtualKeyCode) { case VirtualKeyCodes.Up: { if (ke.Shift) { camControl.GetRange(CameraControlProperty.Zoom, out min, out max, out step, out defaultValue, out camFlags); camControl.Get(CameraControlProperty.Zoom, out currentValue, out camFlags); if (currentValue < max) currentValue += step; camControl.Set(CameraControlProperty.Zoom, currentValue, camFlags); Console.WriteLine("Zoom: {0}", currentValue); } else { camControl.GetRange(CameraControlProperty.Tilt, out min, out max, out step, out defaultValue, out camFlags); camControl.Get(CameraControlProperty.Tilt, out currentValue, out camFlags); if (currentValue > min) currentValue -= step; camControl.Set(CameraControlProperty.Tilt, currentValue, camFlags); Console.WriteLine("Up: {0}", currentValue); } } break; case VirtualKeyCodes.Down: if (ke.Shift) { camControl.GetRange(CameraControlProperty.Zoom, out min, out max, out step, out defaultValue, out camFlags); camControl.Get(CameraControlProperty.Zoom, out currentValue, out camFlags); if (currentValue > min) currentValue -= step; camControl.Set(CameraControlProperty.Zoom, currentValue, camFlags); Console.WriteLine("Zoom: {0}", currentValue); } else { camControl.GetRange(CameraControlProperty.Tilt, out min, out max, out step, out defaultValue, out camFlags); camControl.Get(CameraControlProperty.Tilt, out currentValue, out camFlags); if (currentValue < max) currentValue += step; camControl.Set(CameraControlProperty.Tilt, currentValue, camFlags); Console.WriteLine("Down: {0}", currentValue); } break; case VirtualKeyCodes.Right: camControl.GetRange(CameraControlProperty.Pan, out min, out max, out step, out defaultValue, out camFlags); camControl.Get(CameraControlProperty.Pan, out currentValue, out camFlags); if (currentValue < max) currentValue += step; camControl.Set(CameraControlProperty.Pan, currentValue, camFlags); break; case VirtualKeyCodes.Left: camControl.GetRange(CameraControlProperty.Pan, out min, out max, out step, out defaultValue, out camFlags); camControl.Get(CameraControlProperty.Pan, out currentValue, out camFlags); if (currentValue > min) currentValue -= step; camControl.Set(CameraControlProperty.Pan, currentValue, camFlags); break; case VirtualKeyCodes.PageUp: camControl.GetRange(CameraControlProperty.Focus, out min, out max, out step, out defaultValue, out camFlags); camControl.Get(CameraControlProperty.Focus, out currentValue, out camFlags); if (currentValue > min) currentValue -= step; camControl.Set(CameraControlProperty.Focus, currentValue, CameraControlFlags.Manual); break; case VirtualKeyCodes.PageDown: camControl.GetRange(CameraControlProperty.Focus, out min, out max, out step, out defaultValue, out camFlags); camControl.Get(CameraControlProperty.Focus, out currentValue, out camFlags); if (currentValue < min) currentValue += step; camControl.Set(CameraControlProperty.Focus, currentValue, CameraControlFlags.Manual); break; } //return IntPtr.Zero; }
/// <summary> /// Called when a key is released on the keyboard. /// </summary> /// <param name="ke"></param> public override void OnKeyUp(KeyboardActivityArgs ke) { // Display the virtual key in binary form DisplayBinary(ke); // Display Backspace, Shift, etc. DisplaySpecialsPressed(ke); // Force a redraw Invalidate(); //return IntPtr.Zero; }
public override void OnKeyDown(KeyboardActivityArgs ke) { //Console.WriteLine("SingleLineTextEditor.OnKeyDown: {0}", ke); switch (ke.VirtualKeyCode) { case VirtualKeyCodes.Up: fCaretPosition.Y -= fFontSize.Height; if (fCaretPosition.Y < fCaretStartPosition.Y) fCaretPosition.Y = fCaretStartPosition.Y; Win32Caret.Current.MoveTo(fCaretPosition.X, fCaretPosition.Y); break; case VirtualKeyCodes.Left: fCharacterPosition--; if (fCharacterPosition < fCurrentTextRun.IndexOfFirstCharacter) fCharacterPosition = fCurrentTextRun.IndexOfFirstCharacter; SelectCharacterPosition(fCharacterPosition); break; case VirtualKeyCodes.Right: // If there are no characters in the run, // just return if (0 == fCurrentTextRun.Length) return; // If we're already sitting past the last character // just return if (fCurrentTextRun.IndexOfLastCharacter == fCharacterPosition - 1) return; // Otherwise, increment the character position // and move to that space fCharacterPosition++; if (fCharacterPosition > fCurrentTextRun.IndexOfLastCharacter) fCharacterPosition = fCurrentTextRun.IndexOfLastCharacter + 1; SelectCharacterPosition(fCharacterPosition); break; case VirtualKeyCodes.Insert: // Switch editing mode if (EditMode.Insert == fEditMode) { SetEditMode(EditMode.Overwrite); } else { SetEditMode(EditMode.Insert); } break; case VirtualKeyCodes.Delete: DeleteNextCharacter(); Invalidate(); break; } }
/// <summary> /// Called when a keyboard character is received. This is /// after the system has translated the raw keycode into an /// actual character. /// </summary> /// <param name="kpe"></param> public override void OnKeyPress(KeyboardActivityArgs kpe) { char aChar = kpe.Character; //Console.WriteLine("== OnKeyPress: {0}", (int)aChar); // Test for control codes and replace with space if (aChar < 30) aChar = (char)0x20; BuffStr2[17] = aChar; Invalidate(); //return IntPtr.Zero; }
public static KeyboardActivityArgs CreateFromWindowsMessage(IntPtr windowHandle, int msg, IntPtr wParam, IntPtr lParam) { KeyActivityType kEType = KeyActivityType.None; VirtualKeyCodes virtualKey = VirtualKeyCodes.None; KeyMasks masks = KeyMasks.None; Char aChar = '\0'; UInt64 keyFlags = (UInt64)lParam; //if (((UInt16)User32.GetKeyState((int)VirtualKeyCodes.ShiftKey) & (UInt16)0x8000) > 0) // masks |= KeyMasks.Shift; //if (((UInt16)User32.GetKeyState((int)VirtualKeyCodes.ControlKey) & (UInt16)0x8000) > 0) // masks |= KeyMasks.Control; // The lParam (keyflags) are decoded in the following way // bits 0 - 15 Repeat Count // bits 16 - 23 OEM specific scan code // bit 24 Whether the key is an extended key // bits 25 - 28 Reserved, do not use // bit 29 Context code. Zero for key down // bit 30 Specifies previous key state. // The value is 1 if the key is down before the message is sent, // or it is zero if the key is up. // bit 31 Specifies the transition state. Always zero for keydown int repeatCount = (int)keyFlags & 0xffff; int scanCode = ((int)keyFlags & 0xff0000) >> 16; bool isExtended = (((int)keyFlags & 0x1000000) >> 24) == 1; int context = ((int)keyFlags & 0x20000000) >> 29; bool altPressed; KeyboardActivityArgs ke = null; switch (msg) { case (int)WinMsg.WM_SYSKEYDOWN: kEType = KeyActivityType.SysKeyDown; break; case (int)WinMsg.WM_SYSKEYUP: kEType = KeyActivityType.SysKeyUp; break; case (int)WinMsg.WM_SYSCHAR: kEType = KeyActivityType.SysChar; aChar = (char)wParam; if (1 == context) altPressed = true; break; case (int)WinMsg.WM_KEYDOWN: { kEType = KeyActivityType.KeyDown; virtualKey = (VirtualKeyCodes)wParam.ToInt32(); } break; case (int)WinMsg.WM_KEYUP: { kEType = KeyActivityType.KeyUp; virtualKey = (VirtualKeyCodes)wParam.ToInt32(); } break; case (int)WinMsg.WM_CHAR: kEType = KeyActivityType.KeyChar; aChar = (char)wParam.ToInt32(); if (1 == context) altPressed = true; break; } ke = new KeyboardActivityArgs(null, windowHandle, kEType, virtualKey, masks, scanCode, repeatCount, isExtended, aChar); return ke; }
public override IntPtr OnKeyboardActivity(object sender, KeyboardActivityArgs kbde) { if (kbde.AcitivityType == KeyActivityType.KeyDown) { switch (kbde.VirtualKeyCode) { case VirtualKeyCodes.Left: fDistance -= 1; if (fDistance < 1) fDistance = 1; break; case VirtualKeyCodes.Right: fDistance += 1; break; case VirtualKeyCodes.Down: fDistance = 1; break; } } if (kbde.AcitivityType == KeyActivityType.KeyUp) { switch (kbde.VirtualKeyCode) { case VirtualKeyCodes.Space: animate = !animate; break; case VirtualKeyCodes.D0: case VirtualKeyCodes.NumPad0: curker = 0; //Console.WriteLine("No postprocessing\n"); break; case VirtualKeyCodes.D1: case VirtualKeyCodes.NumPad1: curker = 1; //Console.WriteLine("Sharpen filter\n"); break; case VirtualKeyCodes.D2: case VirtualKeyCodes.NumPad2: curker = 2; //Console.WriteLine("Blur filter\n"); break; case VirtualKeyCodes.D3: case VirtualKeyCodes.NumPad3: curker = 3; //Console.WriteLine("Gaussian blur filter\n"); break; case VirtualKeyCodes.D4: case VirtualKeyCodes.NumPad4: curker = 4; //Console.WriteLine("Edge enhance filter\n"); break; case VirtualKeyCodes.D5: case VirtualKeyCodes.NumPad5: curker = 5; //Console.WriteLine("Edge detect filter\n"); break; case VirtualKeyCodes.D6: case VirtualKeyCodes.NumPad6: curker = 6; //Console.WriteLine("Emboss filter\n"); break; } } return base.OnKeyboardActivity(sender, kbde); }
/// <summary> /// Called when a key is pressed on the keyboard. /// </summary> /// <param name="ke">Contains keyboard event information.</param> public override void OnKeyDown(KeyboardActivityArgs ke) { int i, j; uint keymask; int keycode = (int)ke.VirtualKeyCode; // Store bits for lParam in TextStr0[] i = 0; // counter for keystroke bits j = 0; // offset into string keymask = 0x80000000;// bitmask // Display the virtual key in binary form DisplayBinary(ke); // Store bits for wParam in TextStr1[] // Since the virtual-key code is a 16-bit value only // the 16-low order bits are examined in the code keycode = (int)ke.VirtualKeyCode; i = 0; // counter for keystroke bits j = 18; // initial offset into string keymask = 0x8000; // bitmask // 16-bit loop for (i = 0; i < 16; i++) { // Test for separators and skip if(i == 8) { BuffStr1[j] = (char)0x20; j++; } // Test for 1 and 0 bits and display digits if((keycode & keymask) >0) BuffStr1[j] = '1'; else BuffStr1[j] = '0'; keymask = keymask >> 1; j++; } // Display Backspace, Shift, etc. DisplaySpecialsPressed(ke); // Force WM_PAINT message Invalidate(); //return IntPtr.Zero; }
public override IntPtr OnKeyboardActivity(object sender, KeyboardActivityArgs kbde) { base.OnKeyboardActivity(sender, kbde); float gamma = fGammaCorrection.Gamma; float threshold = fLuminanceThreshold.Threshold; switch (kbde.VirtualKeyCode) { case VirtualKeyCodes.PageUp: // Gamma increase { gamma -= 0.1f; } break; case VirtualKeyCodes.PageDown: // Gamma decrease { gamma = fGammaCorrection.Gamma; gamma += 0.1f; } break; case VirtualKeyCodes.Up: { threshold += 0.01f; if (threshold > 1) threshold = 1; } break; case VirtualKeyCodes.Down: { threshold -= 0.01f; if (threshold < 0) threshold = 0; } break; } if (kbde.AcitivityType == KeyActivityType.KeyUp) { switch (kbde.VirtualKeyCode) { case VirtualKeyCodes.D: fAlphaStep = -fAlphaStep; break; } } fGammaCorrection.Gamma = gamma; fLuminanceThreshold.Threshold = threshold; fLuminanceBinarizer.Threshold = threshold; Console.WriteLine("Gamma: {0} Threshold: {1}", gamma, threshold); return IntPtr.Zero; }