private void onPreviewKeyDown( object sender, KeyEventArgs args ) {
if ( mainMenu != null ) {
if ( mainMenu.TryMatchGesture( args ) ) {
args.Handled = true;
}
}
}
private void Button_KeyDown( object sender, KeyEventArgs args ) {
if (Disabled) return;
if ( args.wVirtualKeyCode == VirtualKeys.Space ) { // VK_SPACE
RaiseEvent(ClickEvent, new RoutedEventArgs(this, ClickEvent));
args.Handled = true;
}
}
private void Button_KeyDown( object sender, KeyEventArgs args ) {
if (Disabled) return;
if ( args.wVirtualKeyCode == VirtualKeys.Space
|| args.wVirtualKeyCode == VirtualKeys.Return) {
RaiseEvent(ClickEvent, new RoutedEventArgs(this, ClickEvent));
pressedUsingKeyboard = true;
Invalidate( );
ConsoleApplication.Instance.Post( ( ) => {
pressedUsingKeyboard = false;
Invalidate( );
}, TimeSpan.FromMilliseconds( 300 ) );
args.Handled = true;
}
}
public bool Matches( KeyEventArgs args ) {
VirtualKeys wVirtualKeyCode = args.wVirtualKeyCode;
if ( this.Key != wVirtualKeyCode ) return false;
ControlKeyState controlKeyState = args.dwControlKeyState;
ModifierKeys modifierKeys = this.Modifiers;
// Проверяем все возможные модификаторы по очереди
if ( ( modifierKeys & ModifierKeys.Alt ) != 0 ) {
if ( ( controlKeyState & ( ControlKeyState.LEFT_ALT_PRESSED
| ControlKeyState.RIGHT_ALT_PRESSED ) ) == 0 ) {
// Должен быть взведён один из флагов, показывающих нажатие Alt, а его нет
return false;
}
} else {
if ( ( controlKeyState & ( ControlKeyState.LEFT_ALT_PRESSED
| ControlKeyState.RIGHT_ALT_PRESSED ) ) != 0 ) {
// Не должно быть взведено ни одного флага, показывающего нажатие Alt,
// а на самом деле - флаг стоит
return false;
}
}
if ( ( modifierKeys & ModifierKeys.Control ) != 0 ) {
if ( ( controlKeyState & ( ControlKeyState.LEFT_CTRL_PRESSED
| ControlKeyState.RIGHT_CTRL_PRESSED ) ) == 0 ) {
return false;
}
} else {
if ( ( controlKeyState & ( ControlKeyState.LEFT_CTRL_PRESSED
| ControlKeyState.RIGHT_CTRL_PRESSED ) ) != 0 ) {
return false;
}
}
if ( ( modifierKeys & ModifierKeys.Shift ) != 0 ) {
if ( ( controlKeyState & ( ControlKeyState.SHIFT_PRESSED ) ) == 0 ) {
return false;
}
} else {
if ( ( controlKeyState & ( ControlKeyState.SHIFT_PRESSED ) ) != 0 ) {
return false;
}
}
return true;
}
private void TextBox_KeyDown(object sender, KeyEventArgs args) {
// todo : add right alt & ctrl support
ConsoleKeyInfo keyInfo = new ConsoleKeyInfo(args.UnicodeChar, (ConsoleKey) args.wVirtualKeyCode,
(args.dwControlKeyState & ControlKeyState.SHIFT_PRESSED) ==
ControlKeyState.SHIFT_PRESSED,
(args.dwControlKeyState & ControlKeyState.LEFT_ALT_PRESSED) ==
ControlKeyState.LEFT_ALT_PRESSED,
(args.dwControlKeyState & ControlKeyState.LEFT_CTRL_PRESSED) ==
ControlKeyState.LEFT_CTRL_PRESSED);
if (!char.IsControl(keyInfo.KeyChar)) {
// insert keychar into a text string according to cursorPosition and offset
if (text != null) {
string leftPart = text.Substring(0, cursorPosition + displayOffset);
string rightPart = text.Substring(cursorPosition + displayOffset);
Text = leftPart + keyInfo.KeyChar + rightPart;
} else {
Text = keyInfo.KeyChar.ToString();
}
if (cursorPosition + 1 < ActualWidth - 2) {
cursorPosition++;
CursorPosition = new Point(cursorPosition + 1, 0);
} else {
displayOffset++;
}
} else {
if (keyInfo.Key == ConsoleKey.Delete) {
if (!String.IsNullOrEmpty(text) && displayOffset + cursorPosition < text.Length) {
string leftPart = text.Substring(0, cursorPosition + displayOffset);
string rightPart = text.Substring(cursorPosition + displayOffset + 1);
Text = leftPart + rightPart;
//
} else {
Console.Beep();
}
}
if (keyInfo.Key == ConsoleKey.Backspace) {
if (!String.IsNullOrEmpty(text) && (displayOffset != 0 || cursorPosition != 0)) {
string leftPart = text.Substring(0, cursorPosition + displayOffset - 1);
string rightPart = text.Substring(cursorPosition + displayOffset);
Text = leftPart + rightPart;
if (displayOffset > 0)
displayOffset--;
else {
if (cursorPosition > 0) {
cursorPosition--;
CursorPosition = new Point(cursorPosition + 1, 0);
}
}
} else {
Console.Beep();
}
}
if (keyInfo.Key == ConsoleKey.LeftArrow) {
if (!String.IsNullOrEmpty(text) && (displayOffset != 0 || cursorPosition != 0)) {
if (cursorPosition > 0) {
cursorPosition--;
CursorPosition = new Point(cursorPosition + 1, 0);
} else {
if (displayOffset > 0) {
displayOffset--;
Invalidate();
}
}
} else {
Console.Beep();
}
}
if (keyInfo.Key == ConsoleKey.RightArrow) {
if (!String.IsNullOrEmpty(text) && displayOffset + cursorPosition < text.Length) {
if (cursorPosition + 1 < ActualWidth - 2) {
cursorPosition++;
CursorPosition = new Point(cursorPosition + 1, 0);
} else {
if (displayOffset + cursorPosition < text.Length) {
displayOffset++;
Invalidate();
}
}
} else {
Console.Beep();
}
}
if (keyInfo.Key == ConsoleKey.Home) {
if (displayOffset != 0 || cursorPosition != 0) {
displayOffset = 0;
cursorPosition = 0;
CursorPosition = new Point(cursorPosition + 1, 0);
Invalidate();
} else {
Console.Beep();
}
}
if (keyInfo.Key == ConsoleKey.End) {
if (!String.IsNullOrEmpty(text) && cursorPosition + displayOffset < ActualWidth - 2) {
displayOffset = text.Length >= ActualWidth - 2 ? text.Length - (ActualWidth - 2) + 1 : 0;
cursorPosition = text.Length >= ActualWidth - 2 ? ActualWidth - 2 - 1 : text.Length;
CursorPosition = new Point(cursorPosition + 1, 0);
Invalidate();
} else {
Console.Beep();
}
}
}
//Debugger.Log(0, "", String.Format("cursorPos : {0} offset {1}\n", cursorPosition, displayOffset));
}
private bool processRoutedEvent(RoutedEvent routedEvent, RoutedEventArgs args) {
//
List<RoutedEventTargetInfo> subscribedTargets = getTargetsSubscribedTo(routedEvent);
Control capturingControl = inputCaptureStack.Count != 0 ? inputCaptureStack.Peek() : null;
//
if (routedEvent.RoutingStrategy == RoutingStrategy.Direct) {
if (null == subscribedTargets)
return false;
//
RoutedEventTargetInfo targetInfo =
subscribedTargets.FirstOrDefault(info => info.target == args.Source);
if (null == targetInfo)
return false;
// если имеется контрол, захватывающий события, события получает только он сам
// и его дочерние контролы
if ( capturingControl != null ) {
if ( !(args.Source is Control) ) return false;
if ( !isControlAllowedToReceiveEvents( ( Control ) args.Source, capturingControl ) )
return false;
}
// copy handlersList to local list to avoid modifications when enumerating
foreach (DelegateInfo delegateInfo in new List< DelegateInfo >(targetInfo.handlersList)) {
if (!args.Handled || delegateInfo.handledEventsToo) {
if (delegateInfo.@delegate is RoutedEventHandler) {
((RoutedEventHandler) delegateInfo.@delegate).Invoke(targetInfo.target, args);
} else {
[email protected](targetInfo.target, args);
}
}
}
}
Control source = (Control) args.Source;
// path to source from root element down to Source
List<Control> path = new List<Control>();
Control current = source;
while (null != current) {
// та же логика с контролом, захватившим обработку сообщений
// если имеется контрол, захватывающий события, события получает только он сам
// и его дочерние контролы
if ( capturingControl == null || isControlAllowedToReceiveEvents( current, capturingControl ) ) {
path.Insert( 0, current );
current = current.Parent;
} else {
break;
}
}
if (routedEvent.RoutingStrategy == RoutingStrategy.Tunnel) {
if (subscribedTargets != null) {
foreach (Control potentialTarget in path) {
Control target = potentialTarget;
RoutedEventTargetInfo targetInfo =
subscribedTargets.FirstOrDefault(info => info.target == target);
if (null != targetInfo) {
foreach (DelegateInfo delegateInfo in new List< DelegateInfo >(targetInfo.handlersList)) {
if (!args.Handled || delegateInfo.handledEventsToo) {
if (delegateInfo.@delegate is RoutedEventHandler) {
((RoutedEventHandler) delegateInfo.@delegate).Invoke(target, args);
} else {
[email protected](target, args);
}
}
}
}
}
}
// для парных Preview-событий запускаем соответствующие настоящие события,
// сохраняя при этом Handled (если Preview событие помечено как Handled=true,
// то и настоящее событие будет маршрутизировано с Handled=true)
if (routedEvent == Control.PreviewMouseDownEvent) {
MouseButtonEventArgs mouseArgs = ( ( MouseButtonEventArgs ) args );
MouseButtonEventArgs argsNew = new MouseButtonEventArgs(
args.Source, Control.MouseDownEvent, mouseArgs.RawPosition,
mouseArgs.LeftButton, mouseArgs.MiddleButton, mouseArgs.RightButton,
mouseArgs.ChangedButton
);
argsNew.Handled = args.Handled;
eventsQueue.Enqueue(argsNew);
}
if (routedEvent == Control.PreviewMouseUpEvent) {
MouseButtonEventArgs mouseArgs = ( ( MouseButtonEventArgs ) args );
MouseButtonEventArgs argsNew = new MouseButtonEventArgs(
args.Source, Control.MouseUpEvent, mouseArgs.RawPosition,
mouseArgs.LeftButton, mouseArgs.MiddleButton, mouseArgs.RightButton,
mouseArgs.ChangedButton
);
argsNew.Handled = args.Handled;
eventsQueue.Enqueue(argsNew);
}
if (routedEvent == Control.PreviewMouseMoveEvent) {
MouseEventArgs mouseArgs = ( ( MouseEventArgs ) args );
MouseEventArgs argsNew = new MouseEventArgs(
args.Source, Control.MouseMoveEvent, mouseArgs.RawPosition,
mouseArgs.LeftButton, mouseArgs.MiddleButton, mouseArgs.RightButton
);
argsNew.Handled = args.Handled;
eventsQueue.Enqueue(argsNew);
}
if ( routedEvent == Control.PreviewMouseWheelEvent ) {
MouseWheelEventArgs oldArgs = ((MouseWheelEventArgs)args);
MouseEventArgs argsNew = new MouseWheelEventArgs(
args.Source, Control.MouseWheelEvent, oldArgs.RawPosition,
oldArgs.LeftButton, oldArgs.MiddleButton, oldArgs.RightButton,
oldArgs.Delta
);
argsNew.Handled = args.Handled;
eventsQueue.Enqueue(argsNew);
}
if (routedEvent == Control.PreviewKeyDownEvent) {
KeyEventArgs argsNew = new KeyEventArgs(args.Source, Control.KeyDownEvent);
KeyEventArgs keyEventArgs = ( ( KeyEventArgs ) args );
argsNew.UnicodeChar = keyEventArgs.UnicodeChar;
argsNew.bKeyDown = keyEventArgs.bKeyDown;
argsNew.dwControlKeyState = keyEventArgs.dwControlKeyState;
argsNew.wRepeatCount = keyEventArgs.wRepeatCount;
argsNew.wVirtualKeyCode = keyEventArgs.wVirtualKeyCode;
argsNew.wVirtualScanCode = keyEventArgs.wVirtualScanCode;
argsNew.Handled = args.Handled;
eventsQueue.Enqueue(argsNew);
}
if (routedEvent == Control.PreviewKeyUpEvent) {
KeyEventArgs argsNew = new KeyEventArgs(args.Source, Control.KeyUpEvent);
KeyEventArgs keyEventArgs = ( ( KeyEventArgs ) args );
argsNew.UnicodeChar = keyEventArgs.UnicodeChar;
argsNew.bKeyDown = keyEventArgs.bKeyDown;
argsNew.dwControlKeyState = keyEventArgs.dwControlKeyState;
argsNew.wRepeatCount = keyEventArgs.wRepeatCount;
argsNew.wVirtualKeyCode = keyEventArgs.wVirtualKeyCode;
argsNew.wVirtualScanCode = keyEventArgs.wVirtualScanCode;
argsNew.Handled = args.Handled;
eventsQueue.Enqueue(argsNew);
}
}
if (routedEvent.RoutingStrategy == RoutingStrategy.Bubble) {
if (subscribedTargets != null) {
for (int i = path.Count - 1; i >= 0; i--) {
Control target = path[i];
RoutedEventTargetInfo targetInfo =
subscribedTargets.FirstOrDefault(info => info.target == target);
if (null != targetInfo) {
//
foreach (DelegateInfo delegateInfo in new List< DelegateInfo >(targetInfo.handlersList)) {
if (!args.Handled || delegateInfo.handledEventsToo) {
if (delegateInfo.@delegate is RoutedEventHandler) {
((RoutedEventHandler) delegateInfo.@delegate).Invoke(target, args);
} else {
[email protected](target, args);
}
}
}
}
}
}
}
return args.Handled;
}
public void ParseInputEvent(INPUT_RECORD inputRecord, Control rootElement) {
if (inputRecord.EventType == EventType.MOUSE_EVENT) {
MOUSE_EVENT_RECORD mouseEvent = inputRecord.MouseEvent;
if (mouseEvent.dwEventFlags != MouseEventFlags.PRESSED_OR_RELEASED &&
mouseEvent.dwEventFlags != MouseEventFlags.MOUSE_MOVED &&
mouseEvent.dwEventFlags != MouseEventFlags.DOUBLE_CLICK &&
mouseEvent.dwEventFlags != MouseEventFlags.MOUSE_WHEELED &&
mouseEvent.dwEventFlags != MouseEventFlags.MOUSE_HWHEELED) {
//
throw new InvalidOperationException("Flags combination in mouse event was not expected.");
}
Point rawPosition;
if (mouseEvent.dwEventFlags == MouseEventFlags.MOUSE_MOVED ||
mouseEvent.dwEventFlags == MouseEventFlags.PRESSED_OR_RELEASED) {
rawPosition = new Point(mouseEvent.dwMousePosition.X, mouseEvent.dwMousePosition.Y);
lastMousePosition = rawPosition;
} else {
// При событии MOUSE_WHEELED в Windows некорректно устанавливается mouseEvent.dwMousePosition
// Поэтому для определения элемента, над которым производится прокручивание колёсика, мы
// вынуждены сохранять координаты, полученные при предыдущем событии мыши
rawPosition = lastMousePosition;
}
Control topMost = findSource(rawPosition, rootElement);
// если мышь захвачена контролом, то события перемещения мыши доставляются только ему,
// события, связанные с нажатием мыши - тоже доставляются только ему, вместо того
// контрола, над которым событие было зарегистрировано. Такой механизм необходим,
// например, для корректной обработки перемещений окон (вверх или в стороны)
Control source = (inputCaptureStack.Count != 0) ? inputCaptureStack.Peek() : topMost;
if (mouseEvent.dwEventFlags == MouseEventFlags.MOUSE_MOVED) {
MouseButtonState leftMouseButtonState = getLeftButtonState(mouseEvent.dwButtonState);
MouseButtonState middleMouseButtonState = getMiddleButtonState(mouseEvent.dwButtonState);
MouseButtonState rightMouseButtonState = getRightButtonState(mouseEvent.dwButtonState);
//
MouseEventArgs mouseEventArgs = new MouseEventArgs(source, Control.PreviewMouseMoveEvent,
rawPosition,
leftMouseButtonState,
middleMouseButtonState,
rightMouseButtonState
);
eventsQueue.Enqueue(mouseEventArgs);
//
lastLeftMouseButtonState = leftMouseButtonState;
lastMiddleMouseButtonState = middleMouseButtonState;
lastRightMouseButtonState = rightMouseButtonState;
// detect mouse enter / mouse leave events
// path to source from root element down
List<Control> mouseOverStack = new List<Control>();
Control current = topMost;
while (null != current) {
mouseOverStack.Insert(0, current);
current = current.Parent;
}
int index;
for (index = 0; index < Math.Min(mouseOverStack.Count, prevMouseOverStack.Count); index++) {
if (mouseOverStack[index] != prevMouseOverStack[index])
break;
}
for (int i = prevMouseOverStack.Count - 1; i >= index; i-- ) {
Control control = prevMouseOverStack[i];
MouseEventArgs args = new MouseEventArgs(control, Control.MouseLeaveEvent,
rawPosition,
leftMouseButtonState,
middleMouseButtonState,
rightMouseButtonState
);
eventsQueue.Enqueue(args);
}
for (int i = index; i < mouseOverStack.Count; i++ ) {
// enqueue MouseEnter event
Control control = mouseOverStack[i];
MouseEventArgs args = new MouseEventArgs(control, Control.MouseEnterEvent,
rawPosition,
leftMouseButtonState,
middleMouseButtonState,
rightMouseButtonState
);
eventsQueue.Enqueue(args);
}
prevMouseOverStack.Clear();
prevMouseOverStack.AddRange(mouseOverStack);
}
if (mouseEvent.dwEventFlags == MouseEventFlags.PRESSED_OR_RELEASED) {
//
MouseButtonState leftMouseButtonState = getLeftButtonState(mouseEvent.dwButtonState);
MouseButtonState middleMouseButtonState = getMiddleButtonState(mouseEvent.dwButtonState);
MouseButtonState rightMouseButtonState = getRightButtonState(mouseEvent.dwButtonState);
//
if (leftMouseButtonState != lastLeftMouseButtonState) {
MouseButtonEventArgs eventArgs = new MouseButtonEventArgs(source,
leftMouseButtonState == MouseButtonState.Pressed ? Control.PreviewMouseDownEvent : Control.PreviewMouseUpEvent,
rawPosition,
leftMouseButtonState,
lastMiddleMouseButtonState,
lastRightMouseButtonState,
MouseButton.Left
);
eventsQueue.Enqueue(eventArgs);
}
if (middleMouseButtonState != lastMiddleMouseButtonState) {
MouseButtonEventArgs eventArgs = new MouseButtonEventArgs(source,
middleMouseButtonState == MouseButtonState.Pressed ? Control.PreviewMouseDownEvent : Control.PreviewMouseUpEvent,
rawPosition,
lastLeftMouseButtonState,
middleMouseButtonState,
lastRightMouseButtonState,
MouseButton.Middle
);
eventsQueue.Enqueue(eventArgs);
}
if (rightMouseButtonState != lastRightMouseButtonState) {
MouseButtonEventArgs eventArgs = new MouseButtonEventArgs(source,
rightMouseButtonState == MouseButtonState.Pressed ? Control.PreviewMouseDownEvent : Control.PreviewMouseUpEvent,
rawPosition,
lastLeftMouseButtonState,
lastMiddleMouseButtonState,
rightMouseButtonState,
MouseButton.Right
);
eventsQueue.Enqueue(eventArgs);
}
//
lastLeftMouseButtonState = leftMouseButtonState;
lastMiddleMouseButtonState = middleMouseButtonState;
lastRightMouseButtonState = rightMouseButtonState;
}
if (mouseEvent.dwEventFlags == MouseEventFlags.MOUSE_WHEELED) {
MouseWheelEventArgs args = new MouseWheelEventArgs(
topMost,
Control.PreviewMouseWheelEvent,
rawPosition,
lastLeftMouseButtonState, lastMiddleMouseButtonState,
lastRightMouseButtonState,
mouseEvent.dwButtonState > 0 ? 1 : -1
);
eventsQueue.Enqueue( args );
}
}
if (inputRecord.EventType == EventType.KEY_EVENT) {
KEY_EVENT_RECORD keyEvent = inputRecord.KeyEvent;
KeyEventArgs eventArgs = new KeyEventArgs(
ConsoleApplication.Instance.FocusManager.FocusedElement,
keyEvent.bKeyDown ? Control.PreviewKeyDownEvent : Control.PreviewKeyUpEvent);
eventArgs.UnicodeChar = keyEvent.UnicodeChar;
eventArgs.bKeyDown = keyEvent.bKeyDown;
eventArgs.dwControlKeyState = keyEvent.dwControlKeyState;
eventArgs.wRepeatCount = keyEvent.wRepeatCount;
eventArgs.wVirtualKeyCode = keyEvent.wVirtualKeyCode;
eventArgs.wVirtualScanCode = keyEvent.wVirtualScanCode;
eventsQueue.Enqueue(eventArgs);
}
}
private void onKeyDown( object sender, KeyEventArgs args ) {
if ( args.wVirtualKeyCode == VirtualKeys.Right ) {
ConsoleApplication.Instance.FocusManager.MoveFocusNext();
args.Handled = true;
}
if ( args.wVirtualKeyCode == VirtualKeys.Left ) {
ConsoleApplication.Instance.FocusManager.MoveFocusPrev();
args.Handled = true;
}
}
public bool TryMatchGesture( KeyEventArgs args ) {
Dictionary< KeyGesture, MenuItem > map = getGesturesMap( );
KeyGesture match = map.Keys.FirstOrDefault( gesture => gesture.Matches( args ) );
if ( match == null ) return false;
this.CloseAllSubmenus( );
// Activate matches menu item
MenuItem menuItem = map[ match ];
List<MenuItem> path = new List< MenuItem >();
MenuItem currentItem = menuItem;
while ( currentItem != null ) {
path.Add( currentItem );
currentItem = currentItem.ParentItem;
}
path.Reverse( );
// Open all menu items in path successively
int i = 0;
Action action = null;
action = new Action(() => {
if (i < path.Count) {
MenuItem item = path[i];
if ( item.Type == MenuItemType.Item ) {
item.RaiseClick( );
return;
}
// Activate focus on item
if ( item.ParentItem == null ) {
ConsoleApplication.Instance.FocusManager.SetFocus( this, item );
} else {
// Set focus to PopupWindow -> item
ConsoleApplication.Instance.FocusManager.SetFocus(
item.Parent.Parent, item );
}
item.Invalidate();
EventHandler handler = null;
// Wait for layout to be revalidated and expand it
handler = (o, eventArgs) => {
item.Expand();
item.LayoutRevalidated -= handler;
i++;
if (i < path.Count) {
action();
}
};
item.LayoutRevalidated += handler;
}
});
action();
return true;
}
protected override void OnPreviewKeyDown( object sender, KeyEventArgs args ) {
switch ( args.wVirtualKeyCode ) {
case VirtualKeys.Right: {
KeyEventArgs newArgs = new KeyEventArgs( this, ControlKeyPressedEvent );
newArgs.wVirtualKeyCode = args.wVirtualKeyCode;
RaiseEvent(ControlKeyPressedEvent, newArgs);
args.Handled = true;
break;
}
case VirtualKeys.Left: {
KeyEventArgs newArgs = new KeyEventArgs(this, ControlKeyPressedEvent);
newArgs.wVirtualKeyCode = args.wVirtualKeyCode;
RaiseEvent(ControlKeyPressedEvent, newArgs);
args.Handled = true;
break;
}
case VirtualKeys.Down:
ConsoleApplication.Instance.FocusManager.MoveFocusNext();
args.Handled = true;
break;
case VirtualKeys.Up:
ConsoleApplication.Instance.FocusManager.MoveFocusPrev();
args.Handled = true;
break;
case VirtualKeys.Escape:
Close();
args.Handled = true;
break;
}
}
private void onKeyDown(object sender, KeyEventArgs args) {
if (args.wVirtualKeyCode == VirtualKeys.Return) {
if (Type == MenuItemType.RootSubmenu || Type == MenuItemType.Submenu)
openMenu();
else if ( Type == MenuItemType.Item ) {
RaiseClick( );
}
args.Handled = true;
}
}
protected virtual void OnPreviewKeyDown(object sender, KeyEventArgs args) {
if (args.wVirtualKeyCode == VirtualKeys.Tab) {
ConsoleApplication.Instance.FocusManager.MoveFocusNext();
args.Handled = true;
}
}
private void OnKeyDown( object sender, KeyEventArgs args )
{
if ( items.Count == 0 ) {
args.Handled = true;
return;
}
if ( args.wVirtualKeyCode == VirtualKeys.PageUp ) {
pageUpCore( PageSize );
}
if ( args.wVirtualKeyCode == VirtualKeys.PageDown ) {
pageDownCore( PageSize );
}
if (args.wVirtualKeyCode == VirtualKeys.Up) {
if ( allItemsAreDisabled ) return;
do {
if ( SelectedItemIndex == 0 || SelectedItemIndex == null )
SelectedItemIndex = items.Count - 1;
else {
SelectedItemIndex--;
}
} while ( disabledItemsIndexes.Contains( SelectedItemIndex.Value ) );
currentItemShouldBeVisibleAtTop();
}
if (args.wVirtualKeyCode == VirtualKeys.Down) {
if ( allItemsAreDisabled ) return;
do {
if ( SelectedItemIndex == null ) SelectedItemIndex = 0;
SelectedItemIndex = ( SelectedItemIndex + 1 )%items.Count;
} while ( disabledItemsIndexes.Contains( SelectedItemIndex.Value ) );
currentItemShouldBeVisibleAtBottom( );
}
args.Handled = true;
}
private void OnKeyDown( object sender, KeyEventArgs args ) {
if ( items.Count == 0 ) {
args.Handled = true;
return;
}
if ( args.wVirtualKeyCode == VirtualKeys.PageUp ) {
pageUpCore( PageSize );
}
if ( args.wVirtualKeyCode == VirtualKeys.PageDown ) {
pageDownCore( PageSize );
}
if (args.wVirtualKeyCode == VirtualKeys.Up) {
if ( SelectedItemIndex == 0 )
SelectedItemIndex = items.Count - 1;
else {
SelectedItemIndex--;
}
Invalidate( );
}
if (args.wVirtualKeyCode == VirtualKeys.Down) {
SelectedItemIndex = (SelectedItemIndex + 1) % items.Count;
Invalidate( );
}
args.Handled = true;
}
private void OnKeyDown( object sender, KeyEventArgs args )
{
if (args.wVirtualKeyCode == VirtualKeys.Escape) {
Close();
} else base.OnPreviewKeyDown( sender, args );
}
private void OnKeyDown( object sender, KeyEventArgs args )
{
if ( args.wVirtualKeyCode == VirtualKeys.Return ) {
openPopup( );
}
}
