/// <summary>
/// Invoked on every keystroke, including system keys such as Alt key combinations.
/// Used to detect keyboard navigation between pages even when the page itself
/// doesn't have focus.
/// </summary>
/// <param name="sender">Instance that triggered the event.</param>
/// <param name="e">Event data describing the conditions that led to the event.</param>
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs e)
{
var virtualKey = e.VirtualKey;
// Only investigate further when Left, Right, or the dedicated Previous or Next keys are pressed
if (e.EventType != CoreAcceleratorKeyEventType.SystemKeyDown &&
e.EventType != CoreAcceleratorKeyEventType.KeyDown ||
virtualKey != VirtualKey.Left && virtualKey != VirtualKey.Right && (int)virtualKey != 166 &&
(int)virtualKey != 167)
{
return;
}
var coreWindow = Window.Current.CoreWindow;
const CoreVirtualKeyStates downState = CoreVirtualKeyStates.Down;
var menuKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState;
var controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState;
var shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState;
var noModifiers = !menuKey && !controlKey && !shiftKey;
var onlyAlt = menuKey && !controlKey && !shiftKey;
if (((int)virtualKey != 166 || !noModifiers) && (virtualKey != VirtualKey.Left || !onlyAlt))
{
return;
}
OnBackRequested();
e.Handled = true;
}
void OnAcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs args)
{
if ((args.EventType == CoreAcceleratorKeyEventType.SystemKeyDown ||
args.EventType == CoreAcceleratorKeyEventType.KeyDown) &&
(args.VirtualKey == VirtualKey.C || args.VirtualKey == VirtualKey.V))
{
CoreWindow window = Window.Current.CoreWindow;
CoreVirtualKeyStates down = CoreVirtualKeyStates.Down;
// Only want case where Ctrl is down
if ((window.GetKeyState(VirtualKey.Shift) & down) == down ||
(window.GetKeyState(VirtualKey.Control) & down) != down ||
(window.GetKeyState(VirtualKey.Menu) & down) == down)
{
return;
}
if (args.VirtualKey == VirtualKey.C)
{
OnCopyAppBarButtonClick(null, null);
}
else if (args.VirtualKey == VirtualKey.V)
{
OnPasteAppBarButtonClick(pasteAppBarButton, null);
}
}
}
public static void GetMetaKeyState(out bool shift, out bool ctrl, out bool alt)
{
GetMetaKeyState(out shift, out ctrl);
CoreVirtualKeyStates keyState = Window.Current.CoreWindow.GetKeyState(VirtualKey.Menu);
alt = (keyState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
}
/// <summary>
/// Invoked on every keystroke, including system keys such as Alt key combinations, when
/// this page is active and occupies the entire window. Used to detect keyboard navigation
/// between pages even when the page itself doesn't have focus.
/// </summary>
/// <param name="sender">Instance that triggered the event.</param>
/// <param name="e">Event data describing the conditions that led to the event.</param>
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs e)
{
VirtualKey virtualKey = e.VirtualKey;
// Only investigate further when Left, Right, or the dedicated Previous or Next keys
// are pressed
if ((e.EventType == CoreAcceleratorKeyEventType.SystemKeyDown ||
e.EventType == CoreAcceleratorKeyEventType.KeyDown) &&
(virtualKey == VirtualKey.Left || virtualKey == VirtualKey.Right ||
(int)virtualKey == 166 || (int)virtualKey == 167))
{
CoreWindow coreWindow = Window.Current.CoreWindow;
CoreVirtualKeyStates downState = CoreVirtualKeyStates.Down;
bool menuKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState;
bool controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState;
bool shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState;
bool noModifiers = !menuKey && !controlKey && !shiftKey;
bool onlyAlt = menuKey && !controlKey && !shiftKey;
if (((int)virtualKey == 166 && noModifiers) ||
(virtualKey == VirtualKey.Left && onlyAlt))
{
// When the previous key or Alt+Left are pressed navigate back
e.Handled = true;
GoBackCommand.Execute(null);
}
else if (((int)virtualKey == 167 && noModifiers) ||
(virtualKey == VirtualKey.Right && onlyAlt))
{
// When the next key or Alt+Right are pressed navigate forward
e.Handled = true;
GoForwardCommand.Execute(null);
}
}
}
private void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender,
AcceleratorKeyEventArgs args)
{
var virtualKey = args.VirtualKey;
if ((args.EventType == CoreAcceleratorKeyEventType.SystemKeyDown ||
args.EventType == CoreAcceleratorKeyEventType.KeyDown) &&
(virtualKey == VirtualKey.Left || virtualKey == VirtualKey.Right ||
(int)virtualKey == 166 || (int)virtualKey == 167))
{
var coreWindow = Window.Current.CoreWindow;
const CoreVirtualKeyStates downState = CoreVirtualKeyStates.Down;
var menuKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState;
var controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState;
var shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState;
var noModifiers = !menuKey && !controlKey && !shiftKey;
var onlyAlt = menuKey && !controlKey && !shiftKey;
if (((int)virtualKey == 166 && noModifiers) ||
(virtualKey == VirtualKey.Left && onlyAlt))
{
args.Handled = true;
GoBack(this, new RoutedEventArgs());
}
else if (((int)virtualKey == 167 && noModifiers) ||
(virtualKey == VirtualKey.Right && onlyAlt))
{
args.Handled = true;
GoForward();
}
}
}
/// <summary>
/// Invoked on every keystroke, including system keys such as Alt key combinations, when
/// this page is active and occupies the entire window. Used to detect keyboard navigation
/// between pages even when the page itself doesn't have focus.
/// </summary>
/// <param name="sender">Instance that triggered the event.</param>
/// <param name="args">Event data describing the conditions that led to the event.</param>
private void CoreDispatcherAcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs args)
{
var virtualKey = args.VirtualKey;
// Only investigate further when Left, Right, or the dedicated Previous or Next keys
// are pressed
if ((args.EventType == CoreAcceleratorKeyEventType.SystemKeyDown ||
args.EventType == CoreAcceleratorKeyEventType.KeyDown) &&
(virtualKey == VirtualKey.Left || virtualKey == VirtualKey.Right ||
(int)virtualKey == 166 || (int)virtualKey == 167))
{
var coreWindow = Window.Current.CoreWindow;
const CoreVirtualKeyStates downState = CoreVirtualKeyStates.Down;
bool menuKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState;
bool controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState;
bool shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState;
bool noModifiers = !menuKey && !controlKey && !shiftKey;
bool onlyAlt = menuKey && !controlKey && !shiftKey;
if (((int)virtualKey == 166 && noModifiers) ||
(virtualKey == VirtualKey.Left && onlyAlt))
{
// When the previous key or Alt+Left are pressed navigate back
args.Handled = true;
GoBack(this, new RoutedEventArgs());
}
}
}
private void OnSplitButtonKeyUp(object sender, KeyRoutedEventArgs args)
{
VirtualKey key = args.Key;
if (key == VirtualKey.Space || key == VirtualKey.Enter || key == VirtualKey.GamepadA)
{
m_isKeyDown = false;
UpdateVisualStates();
// Consider this a click on the primary button
if (IsEnabled)
{
OnClickPrimary(null, null);
args.Handled = true;
}
}
else if (key == VirtualKey.Down)
{
CoreVirtualKeyStates menuState = CoreWindow.GetForCurrentThread().GetKeyState(VirtualKey.Menu);
bool menuKeyDown = (menuState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
if (IsEnabled && menuKeyDown)
{
// Open the menu on alt-down
OpenFlyout();
args.Handled = true;
}
}
else if (key == VirtualKey.F4 && IsEnabled)
{
// Open the menu on F4
OpenFlyout();
args.Handled = true;
}
}
private void CoreWindow_KeyDown(CoreWindow sender, KeyEventArgs args)
{
CoreVirtualKeyStates shift = Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift);
bool isShift = shift.HasFlag(CoreVirtualKeyStates.Down);
switch (args.VirtualKey)
{
case VirtualKey.Down:
_playerDirection.Down = true;
break;
case VirtualKey.Left:
_playerDirection.Left = true;
break;
case VirtualKey.Right:
_playerDirection.Right = true;
break;
case VirtualKey.Up:
_playerDirection.Up = true;
break;
default:
break;
}
}
private void Page_KeyDown(object sender, KeyRoutedEventArgs e)
{
CoreVirtualKeyStates ctrlState = CoreWindow.GetForCurrentThread().GetKeyState(VirtualKey.Control);
if (ctrlState == CoreVirtualKeyStates.Down && e.Key == VirtualKey.S)
{
goalModel.SaveToXml();
}
}
public static void GetMetaKeyState(out bool shift, out bool ctrl)
{
CoreVirtualKeyStates keyState = Window.Current.CoreWindow.GetKeyState(VirtualKey.Control);
ctrl = (keyState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
CoreVirtualKeyStates states2 = Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift);
shift = (states2 & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
}
private async void TabViewContainer_KeyDown(CoreWindow sender, KeyEventArgs args)
{
if (!QueueContentDialog.IsRunningOrWaiting)
{
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.W when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
if (TabViewControl.SelectedItem is TabViewItem Tab)
{
args.Handled = true;
await CleanUpAndRemoveTabItem(Tab);
}
return;
}
}
if (CurrentNavigationControl?.Content is ThisPC PC)
{
switch (args.VirtualKey)
{
case VirtualKey.T when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
await CreateNewTabAsync();
args.Handled = true;
break;
}
case VirtualKey.Space when SettingControl.IsQuicklookEnable:
{
using (FullTrustProcessController.ExclusiveUsage Exclusive = await FullTrustProcessController.GetAvailableController())
{
if (await Exclusive.Controller.CheckIfQuicklookIsAvaliableAsync())
{
if (PC.DeviceGrid.SelectedItem is DriveRelatedData Device && !string.IsNullOrEmpty(Device.Folder.Path))
{
await Exclusive.Controller.ViewWithQuicklookAsync(Device.Folder.Path);
}
else if (PC.LibraryGrid.SelectedItem is LibraryFolder Library && !string.IsNullOrEmpty(Library.Folder.Path))
{
await Exclusive.Controller.ViewWithQuicklookAsync(Library.Folder.Path);
}
}
}
args.Handled = true;
break;
}
private void OnPageKeyDown(object sender, KeyRoutedEventArgs e)
{
if (e.Key == VirtualKey.S)
{
CoreVirtualKeyStates controlState = Window.Current.CoreWindow.GetKeyState(VirtualKey.Control);
if (controlState.HasFlag(CoreVirtualKeyStates.Down) && ViewModel.Save.CanExecute())
{
ViewModel.Save.Execute();
e.Handled = true;
}
}
}
private void SetCapsLock()
{
keystate = Window.Current.CoreWindow.GetKeyState(VirtualKey.CapitalLock);
capsLock = (keystate & CoreVirtualKeyStates.Locked) != 0;
if (capsLock)
{
mainPage.CSignetic6502.MemoryBus.Keyboard.Keystates[7] &= 0xfe;
}
else
{
mainPage.CSignetic6502.MemoryBus.Keyboard.Keystates[7] |= 0x01;
}
}
/// <summary>
/// 탭키다운
/// </summary>
/// <param name="focusedItem"></param>
private void OnTabKeyDown(object focusedItem)
{
#if NETFX_CORE
CoreVirtualKeyStates shiftKeyState = CoreWindow.GetForCurrentThread().GetKeyState(VirtualKey.Shift);
bool shiftKeyDown = (shiftKeyState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
// If we're on the header item then this will be null and we'll still get the default behavior.
switch (focusedItem)
{
case ListViewItem focusedListViewItem:
bool onLastItem = IndexFromContainer(focusedListViewItem) == Items.Count - 1;
bool onFirstItem = IndexFromContainer(focusedListViewItem) == 0;
if (!shiftKeyDown)
{
//tab키를 눌렀을 때 쉬프트키를 누른 상태가 아니라면 기본적으로는 Down이고 마지막 아이템이면 Next
if (onLastItem)
{
TryMoveFocus(FocusNavigationDirection.Next);
}
else
{
TryMoveFocus(FocusNavigationDirection.Down);
}
}
else
{
//Shift + Tab
if (onFirstItem)
{
TryMoveFocus(FocusNavigationDirection.Previous);
}
else
{
TryMoveFocus(FocusNavigationDirection.Up);
}
}
break;
case Control _:
if (!shiftKeyDown)
{
TryMoveFocus(FocusNavigationDirection.Down);
}
else
{
TryMoveFocus(FocusNavigationDirection.Up);
}
break;
}
#endif
}
private void SearchPage_KeyDown(CoreWindow sender, KeyEventArgs args)
{
SearchCommandFlyout.Hide();
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.L when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
Location_Click(null, null);
break;
}
}
}
private void OnKeyDown(object sender, KeyRoutedEventArgs e)
{
CoreVirtualKeyStates ctrl = Window.Current.CoreWindow.GetKeyState(VirtualKey.Control);
if (ctrl.HasFlag(CoreVirtualKeyStates.Down))
{
if (e.OriginalKey == VirtualKey.S)
{
ViewModel.Save.Execute(null);
}
else if (e.OriginalKey == VirtualKey.D)
{
ViewModel.Delete.Execute(null);
}
}
}
/// <summary>
/// Handles setting up the caps lock key handler.
/// </summary>
/// <param name="e"></param>
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
CoreVirtualKeyStates capsState = Window.Current.CoreWindow.GetKeyState(VirtualKey.CapitalLock);
this.capsLockEnabled = (capsState == CoreVirtualKeyStates.Locked);
DebugHelper.Trace($"Got initial caps lock state: {this.capsLockEnabled}");
Window.Current.CoreWindow.KeyDown += CoreWindow_KeyDown;
// XXX - this works around what seems to be a Windows bug where
// when navigating from RootView bindings are not updating.
// Remove when able.
this.Bindings.Update();
}
private void RecycleBin_KeyDown(CoreWindow sender, KeyEventArgs args)
{
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.A when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
ListViewControl.SelectAll();
break;
}
case VirtualKey.Delete when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
case VirtualKey.D when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
PermanentDelete_Click(null, null);
break;
}
}
}
private void SecureArea_KeyDown(CoreWindow sender, KeyEventArgs args)
{
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.A when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
SecureGridView.SelectAll();
break;
}
case VirtualKey.Delete when SecureGridView.SelectedItems.Count > 0:
case VirtualKey.D when CtrlState.HasFlag(CoreVirtualKeyStates.Down) && SecureGridView.SelectedItems.Count > 0:
{
DeleteFile_Click(null, null);
break;
}
}
}
private void SearchPage_KeyDown(CoreWindow sender, KeyEventArgs args)
{
CloseAllFlyout();
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.L when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
Location_Click(null, null);
break;
}
case VirtualKey.A when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
SearchResultList.SelectAll();
break;
}
case VirtualKey.C when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
Copy_Click(null, null);
break;
}
case VirtualKey.X when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
Cut_Click(null, null);
break;
}
case VirtualKey.Delete:
case VirtualKey.D when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
Delete_Click(null, null);
break;
}
}
}
internal static byte GetShiftCode(VirtualKey virtualKey, byte current, bool isDown)
{
byte result = 0;
CoreVirtualKeyStates shiftState = Window.Current.CoreWindow.GetAsyncKeyState(VirtualKey.Shift);
CoreVirtualKeyStates capitalLockState = Window.Current.CoreWindow.GetAsyncKeyState(VirtualKey.CapitalLock);
bool shiftIsDown = shiftState != CoreVirtualKeyStates.None ||
capitalLockState != CoreVirtualKeyStates.None ||
virtualKey == VirtualKey.Shift ||
virtualKey == VirtualKey.LeftShift ||
virtualKey == VirtualKey.RightShift;
if (shiftIsDown)
{
int bitIndex = 1;
byte mask = (byte)(1 << bitIndex);
result |= mask;
}
return(result);
}
private void Init()
{
CSignetic6502 = new CSignetic6502(mainPage);
CClock = new CClock(this);
CSignetic6502.MemoryBus.VDU.InitCVDU(this, gridScreen);
cbSelectNumberOfLines.SelectedIndex = 1;
keystate = Window.Current.CoreWindow.GetKeyState(VirtualKey.NumberKeyLock);
numLock = (keystate & CoreVirtualKeyStates.Locked) != 0;
keystate = Window.Current.CoreWindow.GetKeyState(VirtualKey.CapitalLock);
capsLock = (keystate & CoreVirtualKeyStates.Locked) != 0;
Midi = new MIDI(this);
SetPage(0);
btnHistory.Background = new SolidColorBrush(Color.FromArgb(255, 160, 160, 64));
btnTheProject.Background = new SolidColorBrush(Color.FromArgb(255, 160, 160, 160));
btnOperation.Background = new SolidColorBrush(Color.FromArgb(255, 160, 160, 160));
btnManuals.Background = new SolidColorBrush(Color.FromArgb(255, 160, 160, 160));
btnCompukitUK101.Background = new SolidColorBrush(Color.FromArgb(255, 160, 160, 64));
btnCegmon.Background = new SolidColorBrush(Color.FromArgb(255, 160, 160, 160));
cbSelectACIAUsage.SelectedIndex = 0;
Editor = new Editor(this);
handleControlEvents = true;
}
/// <summary>
/// Handles KeyDown events for the current window.
/// </summary>
/// <param name="sender">The CoreWindow that dispatched the event.</param>
/// <param name="args">KeyEventArgs for the event.</param>
private async void CoreWindow_KeyDown(CoreWindow sender, KeyEventArgs args)
{
CoreVirtualKeyStates ctrlState = sender.GetKeyState(VirtualKey.Control);
if ((ctrlState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down)
{
CoreVirtualKeyStates shiftState = sender.GetKeyState(VirtualKey.Shift);
bool shiftDown = (shiftState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
// Handle accelerator (Ctrl) hotkeys
switch (args.VirtualKey)
{
case VirtualKey.O:
if (!shiftDown)
{
// Prompt to open a file
args.Handled = true;
await PickFileForOpenAsync(
file =>
{
OpenFile(file);
}
);
}
break;
default:
args.Handled = ((PassKeepPage)this.contentFrame.Content).HandleAcceleratorKey(args.VirtualKey, shiftDown);
break;
}
}
else
{
if (args.VirtualKey == VirtualKey.Escape)
{
ViewModel.TaskNotificationService.RequestCancellation();
}
}
}
void OnAcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs args)
{
if ((args.EventType == CoreAcceleratorKeyEventType.SystemKeyDown ||
args.EventType == CoreAcceleratorKeyEventType.KeyDown) &&
(args.VirtualKey == VirtualKey.Left ||
args.VirtualKey == VirtualKey.Right ||
(int)args.VirtualKey == 166 ||
(int)args.VirtualKey == 167))
{
CoreWindow window = Window.Current.CoreWindow;
CoreVirtualKeyStates down = CoreVirtualKeyStates.Down;
// Ignore key combinations where Shift or Ctrl is down
if ((window.GetKeyState(VirtualKey.Shift) & down) == down ||
(window.GetKeyState(VirtualKey.Control) & down) == down)
{
return;
}
// Get alt key state
bool alt = (window.GetKeyState(VirtualKey.Menu) & down) == down;
// Go back for Alt-Left key or browser left key
if (args.VirtualKey == VirtualKey.Left && alt ||
(int)args.VirtualKey == 166 && !alt)
{
GoBack();
args.Handled = true;
}
// Go forward for Alt-Right key or browser right key
if (args.VirtualKey == VirtualKey.Right && alt ||
(int)args.VirtualKey == 167 && !alt)
{
GoForward();
args.Handled = true;
}
}
}
private void RecycleBin_KeyDown(CoreWindow sender, KeyEventArgs args)
{
if (!LoadingControl.IsLoading)
{
SelectFlyout.Hide();
EmptyFlyout.Hide();
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.A when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
ListViewControl.SelectAll();
break;
}
case VirtualKey.Delete:
case VirtualKey.D when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
PermanentDelete_Click(null, null);
break;
}
case VirtualKey.R when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
RestoreRecycle_Click(null, null);
break;
}
case VirtualKey.E when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
ClearRecycleBin_Click(null, null);
break;
}
}
}
}
public static bool IsKeyPressed(VirtualKey key)
{
CoreVirtualKeyStates controlKeyState = Window.Current.CoreWindow.GetKeyState(key);
return((controlKeyState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down);
}
private async void OnKeyboards(CoreWindow sender, KeyEventArgs args)
{
try
{
CoreVirtualKeyStates controlKeyState = Window.Current.CoreWindow.GetKeyState(VirtualKey.Control);
var isCtrlDown = (controlKeyState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
CoreVirtualKeyStates shiftKeyState = Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift);
var isShiftDown = (shiftKeyState & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down;
var ctrl = Window.Current.CoreWindow.GetKeyState(VirtualKey.Control);
var shift = Window.Current.CoreWindow.GetKeyState(VirtualKey.Shift);
switch (args.VirtualKey)
{
case VirtualKey.Escape:
//NavigationService.GoBack();
break;
}
if (isCtrlDown && args.VirtualKey == VirtualKey.Left || args.VirtualKey == VirtualKey.Escape)
{
NavigationService.GoBack();
}
if (isCtrlDown && args.VirtualKey == VirtualKey.V || isShiftDown && args.VirtualKey == VirtualKey.Insert)
{
if (InstaApi != null && InstaApi.IsUserAuthenticated)
{
DataPackageView dataPackageView = Clipboard.GetContent();
if (dataPackageView.Contains(StandardDataFormats.StorageItems))
{
var items = await dataPackageView.GetStorageItemsAsync();
if (items.Count > 0)
{
if (items[0] is StorageFile file)
{
if (file.Path.IsSupportedImage()) // IsSupportedVideo ?
{
if (NavigationService.Frame.Content is Views.Direct.ThreadView thread)
{
thread.UploadFile(file);
}
else
{
await new ContentDialogs.FileAssociationDialog(file).ShowAsync();
}
}
else
{
ShowNotify("This file is not supported.\r\n" + file.Path, 3000);
}
}
}
}
else if (dataPackageView.Contains(StandardDataFormats.Bitmap))
{
var bitmap = await dataPackageView.GetBitmapAsync();
var decoder = await BitmapDecoder.CreateAsync(await bitmap.OpenReadAsync());
var file = await GenerateRandomOutputFile();
var encoder = await BitmapEncoder.CreateForTranscodingAsync(await file.OpenAsync(FileAccessMode.ReadWrite), decoder);
await encoder.FlushAsync();
if (NavigationService.Frame.Content is Views.Direct.ThreadView thread)
{
thread.UploadFile(file);
}
else
{
await new ContentDialogs.FileAssociationDialog(file).ShowAsync();
}
}
}
}
}
catch { }
}
public static bool IsDown(this VirtualKey key)
{
CoreVirtualKeyStates state = Window.Current.CoreWindow.GetKeyState(key);
return((state & CoreVirtualKeyStates.Down) == CoreVirtualKeyStates.Down);
}
private async void TabViewContainer_KeyDown(CoreWindow sender, KeyEventArgs args)
{
if (!QueueContentDialog.IsRunningOrWaiting)
{
CoreVirtualKeyStates CtrlState = sender.GetKeyState(VirtualKey.Control);
switch (args.VirtualKey)
{
case VirtualKey.W when CtrlState.HasFlag(CoreVirtualKeyStates.Down):
{
if (TabViewControl.SelectedItem is TabViewItem Tab)
{
args.Handled = true;
await CleanUpAndRemoveTabItem(Tab).ConfigureAwait(true);
}
return;
}
}
if (CurrentTabNavigation?.Content is ThisPC PC)
{
switch (args.VirtualKey)
{
case VirtualKey.Space when SettingControl.IsQuicklookAvailable && SettingControl.IsQuicklookEnable:
{
if (PC.DeviceGrid.SelectedItem is HardDeviceInfo Device)
{
await FullTrustProcessController.Current.ViewWithQuicklookAsync(Device.Folder.Path).ConfigureAwait(false);
}
else if (PC.LibraryGrid.SelectedItem is LibraryFolder Library)
{
await FullTrustProcessController.Current.ViewWithQuicklookAsync(Library.Folder.Path).ConfigureAwait(false);
}
break;
}
case VirtualKey.Enter:
{
if (PC.DeviceGrid.SelectedItem is HardDeviceInfo Device)
{
if (string.IsNullOrEmpty(Device.Folder.Path))
{
QueueContentDialog Dialog = new QueueContentDialog
{
Title = Globalization.GetString("Common_Dialog_TipTitle"),
Content = Globalization.GetString("QueueDialog_MTP_CouldNotAccess_Content"),
PrimaryButtonText = Globalization.GetString("Common_Dialog_ContinueButton"),
CloseButtonText = Globalization.GetString("Common_Dialog_CancelButton")
};
if ((await Dialog.ShowAsync().ConfigureAwait(true)) == ContentDialogResult.Primary)
{
await Launcher.LaunchFolderAsync(Device.Folder);
}
}
else
{
if (AnimationController.Current.IsEnableAnimation)
{
CurrentTabNavigation.Navigate(typeof(FileControl), new Tuple <WeakReference <TabViewItem>, string>(new WeakReference <TabViewItem>(TabViewControl.SelectedItem as TabViewItem), Device.Folder.Path), new DrillInNavigationTransitionInfo());
}
else
{
CurrentTabNavigation.Navigate(typeof(FileControl), new Tuple <WeakReference <TabViewItem>, string>(new WeakReference <TabViewItem>(TabViewControl.SelectedItem as TabViewItem), Device.Folder.Path), new SuppressNavigationTransitionInfo());
}
}
args.Handled = true;
}
else if (PC.LibraryGrid.SelectedItem is LibraryFolder Library)
{
if (AnimationController.Current.IsEnableAnimation)
{
CurrentTabNavigation.Navigate(typeof(FileControl), new Tuple <WeakReference <TabViewItem>, string>(new WeakReference <TabViewItem>(TabViewControl.SelectedItem as TabViewItem), Library.Folder.Path), new DrillInNavigationTransitionInfo());
}
else
{
CurrentTabNavigation.Navigate(typeof(FileControl), new Tuple <WeakReference <TabViewItem>, string>(new WeakReference <TabViewItem>(TabViewControl.SelectedItem as TabViewItem), Library.Folder.Path), new SuppressNavigationTransitionInfo());
}
args.Handled = true;
}
break;
}
case VirtualKey.F5:
{
PC.Refresh_Click(null, null);
args.Handled = true;
break;
}
}
}
}
}
private static void CoreDispatcher_AcceleratorKeyActivated(CoreDispatcher sender, AcceleratorKeyEventArgs e)
{
const CoreVirtualKeyStates downState = CoreVirtualKeyStates.Down;
var coreWindow = Window.Current.CoreWindow;
var menuKey = (coreWindow.GetKeyState(VirtualKey.Menu) & downState) == downState;
var controlKey = (coreWindow.GetKeyState(VirtualKey.Control) & downState) == downState;
var shiftKey = (coreWindow.GetKeyState(VirtualKey.Shift) & downState) == downState;
var noModifiers = !menuKey && !controlKey && !shiftKey;
if (!noModifiers || e.EventType != CoreAcceleratorKeyEventType.KeyDown ||
(e.VirtualKey != VirtualKey.Enter && e.VirtualKey != VirtualKey.Escape))
{
return;
}
var frame = Window.Current.Content as Frame;
if (frame == null)
{
return;
}
var currentPage = frame.Content as Page;
if (currentPage == null)
{
return;
}
if (e.VirtualKey == VirtualKey.Enter)
{
// Quick check to avoid TextBox with ENTER support
var tb = FocusManager.GetFocusedElement() as TextBox;
if (tb != null && tb.AcceptsReturn)
{
return;
}
var defaultButton = currentPage.GetValue(DefaultButtonProperty) as Button;
if (defaultButton == null || !defaultButton.IsEnabled)
{
return;
}
var peer = new ButtonAutomationPeer(defaultButton);
var invokeProv = peer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
if (invokeProv != null)
{
invokeProv.Invoke();
}
}
else
{
var cancelButton = currentPage.GetValue(CancelButtonProperty) as Button;
if (cancelButton == null || !cancelButton.IsEnabled)
{
return;
}
var peer = new ButtonAutomationPeer(cancelButton);
var invokeProv = peer.GetPattern(PatternInterface.Invoke) as IInvokeProvider;
if (invokeProv != null)
{
invokeProv.Invoke();
}
}
}
