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;
}
