/*
 * InputHandler.cpp
 * ----------------
 * Purpose: Implementation of keyboard input handling, keymap loading, ...
 * Notes  : (currently none)
 * Authors: OpenMPT Devs
 * The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
 */


#include "stdafx.h"
#include "CommandSet.h"
#include "InputHandler.h"
#include "resource.h"
#include "Mainfrm.h"
#include "../soundlib/MIDIEvents.h"


OPENMPT_NAMESPACE_BEGIN


#define TRANSITIONBIT 0x8000
#define REPEATBIT 0x4000

CInputHandler::CInputHandler(CWnd *mainframe)
{
	m_pMainFrm = mainframe;

	//Init CommandSet and Load defaults
	m_activeCommandSet = std::make_unique<CCommandSet>();
	m_lastCommands.fill(kcNull);

	mpt::PathString sDefaultPath = theApp.GetConfigPath() + P_("Keybindings.mkb");

	const bool bNoExistingKbdFileSetting = TrackerSettings::Instance().m_szKbdFile.empty();

	// 1. Try to load keybindings from the path saved in the settings.
	// 2. If the setting doesn't exist or the loading fails, try to load from default location.
	// 3. If neither one of these worked, load default keybindings from resources.
	// 4. If there were no keybinding setting already, create a keybinding file to default location
	//    and set its path to settings.

	if (bNoExistingKbdFileSetting || !(m_activeCommandSet->LoadFile(TrackerSettings::Instance().m_szKbdFile)))
	{
		if (bNoExistingKbdFileSetting)
			TrackerSettings::Instance().m_szKbdFile = sDefaultPath;
		bool bSuccess = false;
		if (sDefaultPath.IsFile())
			bSuccess = m_activeCommandSet->LoadFile(sDefaultPath);
		if (!bSuccess)
		{
			// Load keybindings from resources.
			MPT_LOG_GLOBAL(LogDebug, "InputHandler", U_("Loading keybindings from resources\n"));
			bSuccess = m_activeCommandSet->LoadDefaultKeymap();
			if (bSuccess && bNoExistingKbdFileSetting)
			{
				m_activeCommandSet->SaveFile(TrackerSettings::Instance().m_szKbdFile);
			}
		}
		if (!bSuccess)
			ErrorBox(IDS_UNABLE_TO_LOAD_KEYBINDINGS);
	}
	// We will only overwrite the default Keybindings.mkb file from now on.
	TrackerSettings::Instance().m_szKbdFile = sDefaultPath;

	//Get Keymap
	m_activeCommandSet->GenKeyMap(m_keyMap);
	SetupSpecialKeyInterception(); // Feature: use Windows keys as modifier keys, intercept special keys
}


CommandID CInputHandler::SendCommands(CWnd *wnd, const KeyMapRange &cmd)
{
	CommandID executeCommand = kcNull;
	if(wnd != nullptr)
	{
		// Some commands (e.g. open/close/document switching) may invalidate the key map and thus its iterators.
		// To avoid this problem, copy over the elements we are interested in before sending commands.
		std::vector<KeyMap::value_type> commands;
		commands.reserve(std::distance(cmd.first, cmd.second));
		for(auto i = cmd.first; i != cmd.second; i++)
		{
			commands.push_back(*i);
		}
		for(const auto &i : commands)
		{
			m_lastCommands[m_lastCommandPos] = i.second;
			m_lastCommandPos = (m_lastCommandPos + 1) % m_lastCommands.size();
			if(wnd->SendMessage(WM_MOD_KEYCOMMAND, i.second, i.first.AsLPARAM()) != kcNull)
			{
				// Command was handled, no need to let the OS handle the key
				executeCommand = i.second;
			}
		}
	}
	return executeCommand;
}


CommandID CInputHandler::GeneralKeyEvent(InputTargetContext context, int code, WPARAM wParam, LPARAM lParam)
{
	KeyMapRange cmd = { m_keyMap.end(), m_keyMap.end() };
	KeyEventType keyEventType;

	if(code == HC_ACTION)
	{
		//Get the KeyEventType (key up, key down, key repeat)
		DWORD scancode = static_cast<LONG>(lParam) >> 16;
		if((scancode & 0xC000) == 0xC000)
		{
			keyEventType = kKeyEventUp;
		} else if((scancode & 0xC000) == 0x0000)
		{
			keyEventType = kKeyEventDown;
		} else
		{
			keyEventType = kKeyEventRepeat;
		}

		// Catch modifier change (ctrl, alt, shift) - Only check on keyDown or keyUp.
		// NB: we want to catch modifiers even when the input handler is locked
		if(keyEventType == kKeyEventUp || keyEventType == kKeyEventDown)
		{
			scancode = (static_cast<LONG>(lParam) >> 16) & 0x1FF;
			CatchModifierChange(wParam, keyEventType, scancode);
		}

		if(!InterceptSpecialKeys(static_cast<UINT>(wParam), static_cast<LONG>(lParam), true) && !IsBypassed())
		{
			// only execute command when the input handler is not locked
			// and the input is not a consequence of special key interception.
			cmd = m_keyMap.equal_range(KeyCombination(context, m_modifierMask, static_cast<UINT>(wParam), keyEventType));
		}
	}
	if(code == HC_MIDI)
	{
		cmd = m_keyMap.equal_range(KeyCombination(context, ModMidi, static_cast<UINT>(wParam), static_cast<KeyEventType>(lParam)));
	}

	return SendCommands(m_pMainFrm, cmd);
}


CommandID CInputHandler::KeyEvent(InputTargetContext context, UINT &nChar, UINT &/*nRepCnt*/, UINT &nFlags, KeyEventType keyEventType, CWnd *pSourceWnd)
{
	if(InterceptSpecialKeys(nChar, nFlags, false))
		return kcDummyShortcut;
	KeyMapRange cmd = m_keyMap.equal_range(KeyCombination(context, m_modifierMask, nChar, keyEventType));

	if(pSourceWnd == nullptr)
		pSourceWnd = m_pMainFrm;	// By default, send command message to main frame.
	return SendCommands(pSourceWnd, cmd);
}


// Feature: use Windows keys as modifier keys, intercept special keys
bool CInputHandler::InterceptSpecialKeys(UINT nChar, UINT nFlags, bool generateMsg)
{
	KeyEventType keyEventType = GetKeyEventType(HIWORD(nFlags));
	enum { VK_NonExistentKey = VK_F24+1 };

	if(nChar == VK_NonExistentKey)
	{
		return true;
	} else if(m_bInterceptWindowsKeys && (nChar == VK_LWIN || nChar == VK_RWIN))
	{
		if(keyEventType == kKeyEventDown)
		{
			INPUT inp[2];
			inp[0].type = inp[1].type = INPUT_KEYBOARD;
			inp[0].ki.time = inp[1].ki.time = 0;
			inp[0].ki.dwExtraInfo = inp[1].ki.dwExtraInfo = 0;
			inp[0].ki.wVk = inp[1].ki.wVk = VK_NonExistentKey;
			inp[0].ki.wScan = inp[1].ki.wScan = 0;
			inp[0].ki.dwFlags = 0;
			inp[1].ki.dwFlags = KEYEVENTF_KEYUP;
			SendInput(2, inp, sizeof(INPUT));
		}
	}

	if((nChar == VK_NUMLOCK && m_bInterceptNumLock)
		|| (nChar == VK_CAPITAL && m_bInterceptCapsLock)
		|| (nChar == VK_SCROLL && m_bInterceptScrollLock))
	{
		if(GetMessageExtraInfo() == 0xC0FFEE)
		{
			SetMessageExtraInfo(0);
			return true;
		} else if(keyEventType == kKeyEventDown && generateMsg)
		{
			// Prevent keys from lighting up by simulating a second press.
			INPUT inp[2];
			inp[0].type = inp[1].type = INPUT_KEYBOARD;
			inp[0].ki.time = inp[1].ki.time = 0;
			inp[0].ki.dwExtraInfo = inp[1].ki.dwExtraInfo = 0xC0FFEE;
			inp[0].ki.wVk = inp[1].ki.wVk = static_cast<WORD>(nChar);
			inp[0].ki.wScan = inp[1].ki.wScan = 0;
			inp[0].ki.dwFlags = KEYEVENTF_KEYUP;
			inp[1].ki.dwFlags = 0;
			SendInput(2, inp, sizeof(INPUT));
		}
	}
	return false;
};


void CInputHandler::SetupSpecialKeyInterception()
{
	m_bInterceptWindowsKeys = m_bInterceptNumLock = m_bInterceptCapsLock = m_bInterceptScrollLock = false;
	for(const auto &i : m_keyMap)
	{
		ASSERT(i.second != kcNull);
		if(i.first.Modifier() == ModWin)
			m_bInterceptWindowsKeys = true;
		if(i.first.KeyCode() == VK_NUMLOCK)
			m_bInterceptNumLock = true;
		if(i.first.KeyCode() == VK_CAPITAL)
			m_bInterceptCapsLock = true;
		if(i.first.KeyCode() == VK_SCROLL)
			m_bInterceptScrollLock = true;
	}
};


//Deal with Modifier keypresses. Private surouting used above.
bool CInputHandler::CatchModifierChange(WPARAM wParam, KeyEventType keyEventType, int scancode)
{
	FlagSet<Modifiers> modifierMask = ModNone;
	// Scancode for right modifier keys should have bit 8 set, but Right Shift is actually 0x36.
	const bool isRight = ((scancode & 0x100) || scancode == 0x36) && TrackerSettings::Instance().MiscDistinguishModifiers;
	switch(wParam)
	{
		case VK_CONTROL:
			modifierMask.set(isRight ? ModRCtrl : ModCtrl);
			break;
		case VK_SHIFT:
			modifierMask.set(isRight ? ModRShift : ModShift);
			break;
		case VK_MENU:
			modifierMask.set(isRight ? ModRAlt : ModAlt);
			break;
		case VK_LWIN: case VK_RWIN: // Feature: use Windows keys as modifier keys
			modifierMask.set(ModWin);
			break;
	}

	if (modifierMask)	// This keypress just changed the modifier mask
	{
		if (keyEventType == kKeyEventDown)
		{
			m_modifierMask.set(modifierMask);
			// Right Alt is registered as Ctrl+Alt.
			// Left Ctrl + Right Alt seems like a pretty difficult to use key combination anyway, so just ignore Ctrl.
			if(scancode == 0x138)
				m_modifierMask.reset(ModCtrl);
#ifdef _DEBUG
			LogModifiers();
#endif
		} else if (keyEventType == kKeyEventUp)
			m_modifierMask.reset(modifierMask);

		return true;
	}

	return false;
}


// Translate MIDI messages to shortcut commands
CommandID CInputHandler::HandleMIDIMessage(InputTargetContext context, uint32 message)
{
	auto byte1 = MIDIEvents::GetDataByte1FromEvent(message), byte2 = MIDIEvents::GetDataByte2FromEvent(message);
	switch(MIDIEvents::GetTypeFromEvent(message))
	{
	case MIDIEvents::evControllerChange:
		if(byte2 != 0)
		{
			// Only capture MIDI CCs for now. Some controllers constantly send some MIDI CCs with value 0
			// (e.g. the Roland D-50 sends CC123 whenenver all notes have been released), so we will ignore those.
			return GeneralKeyEvent(context, HC_MIDI, byte1, kKeyEventDown);
		}
		break;

	case MIDIEvents::evNoteOff:
		byte2 = 0;
		[[fallthrough]];
	case MIDIEvents::evNoteOn:
		if(byte2 != 0)
		{
			return GeneralKeyEvent(context, HC_MIDI, byte1 | 0x80, kKeyEventDown);
		} else
		{
			// If the key-down triggered a note, we still want that note to be stopped. So we always pretend that no key was assigned to this event
			GeneralKeyEvent(context, HC_MIDI, byte1 | 0x80, kKeyEventUp);
		}
		break;
	}

	return kcNull;
}


int CInputHandler::GetKeyListSize(CommandID cmd) const
{
	return m_activeCommandSet->GetKeyListSize(cmd);
}


//----------------------- Misc


void CInputHandler::LogModifiers()
{
	MPT_LOG_GLOBAL(LogDebug, "InputHandler", U_("----------------------------------\n"));
	MPT_LOG_GLOBAL(LogDebug, "InputHandler", m_modifierMask[ModCtrl] ? U_("Ctrl On") : U_("Ctrl --"));
	MPT_LOG_GLOBAL(LogDebug, "InputHandler", m_modifierMask[ModShift] ? U_("\tShft On") : U_("\tShft --"));
	MPT_LOG_GLOBAL(LogDebug, "InputHandler", m_modifierMask[ModAlt] ? U_("\tAlt  On") : U_("\tAlt  --"));
	MPT_LOG_GLOBAL(LogDebug, "InputHandler", m_modifierMask[ModWin] ? U_("\tWin  On\n") : U_("\tWin  --\n"));
}


KeyEventType CInputHandler::GetKeyEventType(UINT nFlags)
{
	if (nFlags & TRANSITIONBIT)
	{
		// Key released
		return kKeyEventUp;
	} else if (nFlags & REPEATBIT)
	{
		// Key repeated
		return kKeyEventRepeat;
	} else
	{
		// New key down
		return kKeyEventDown;
	}
}


bool CInputHandler::SelectionPressed() const
{
	int nSelectionKeys = m_activeCommandSet->GetKeyListSize(kcSelect);
	KeyCombination key;

	for (int k=0; k<nSelectionKeys; k++)
	{
		key = m_activeCommandSet->GetKey(kcSelect, k);
		if (m_modifierMask & key.Modifier())
		{
			return true;
		}
	}
	return false;
}


bool CInputHandler::ShiftPressed() const
{
	return m_modifierMask[ModShift | ModRShift];
}


bool CInputHandler::CtrlPressed() const
{
	return m_modifierMask[ModCtrl | ModRCtrl];
}


bool CInputHandler::AltPressed() const
{
	return m_modifierMask[ModAlt | ModRAlt];
}


void CInputHandler::Bypass(bool b)
{
	if(b)
		m_bypassCount++;
	else
		m_bypassCount--;
	ASSERT(m_bypassCount >= 0);
}


bool CInputHandler::IsBypassed() const
{
	return m_bypassCount > 0;
}


FlagSet<Modifiers> CInputHandler::GetModifierMask() const
{
	return m_modifierMask;
}


void CInputHandler::SetModifierMask(FlagSet<Modifiers> mask)
{
	m_modifierMask = mask;
}


CString CInputHandler::GetKeyTextFromCommand(CommandID c, const TCHAR *prependText) const
{
	CString s;
	if(prependText != nullptr)
	{
		s = prependText;
		s.AppendChar(_T('\t'));
	}
	s += m_activeCommandSet->GetKeyTextFromCommand(c, 0);
	return s;
}


CString CInputHandler::GetMenuText(UINT id) const
{
	static constexpr std::tuple<UINT, CommandID, const TCHAR *> MenuItems[] =
	{
		{ ID_FILE_NEW,            kcFileNew,           _T("&New") },
		{ ID_FILE_OPEN,           kcFileOpen,          _T("&Open...") },
		{ ID_FILE_OPENTEMPLATE,   kcNull,              _T("Open &Template") },
		{ ID_FILE_CLOSE,          kcFileClose,         _T("&Close") },
		{ ID_FILE_CLOSEALL,       kcFileCloseAll,      _T("C&lose All") },
		{ ID_FILE_APPENDMODULE,   kcFileAppend,        _T("Appen&d Module...") },
		{ ID_FILE_SAVE,           kcFileSave,          _T("&Save") },
		{ ID_FILE_SAVE_AS,        kcFileSaveAs,        _T("Save &As...") },
		{ ID_FILE_SAVE_COPY,      kcFileSaveCopy,      _T("Save Cop&y...") },
		{ ID_FILE_SAVEASTEMPLATE, kcFileSaveTemplate,  _T("Sa&ve as Template") },
		{ ID_FILE_SAVEASWAVE,     kcFileSaveAsWave,    _T("Stream Export (&WAV, FLAC, MP3, etc.)...") },
		{ ID_FILE_SAVEMIDI,       kcFileSaveMidi,      _T("Export as M&IDI...") },
		{ ID_FILE_SAVEOPL,        kcFileSaveOPL,       _T("Export O&PL Register Dump...") },
		{ ID_FILE_SAVECOMPAT,     kcFileExportCompat,  _T("Compatibility &Export...") },
		{ ID_IMPORT_MIDILIB,      kcFileImportMidiLib, _T("Import &MIDI Library...") },
		{ ID_ADD_SOUNDBANK,       kcFileAddSoundBank,  _T("Add Sound &Bank...") },

		{ ID_PLAYER_PLAY,          kcPlayPauseSong,      _T("Pause / &Resume") },
		{ ID_PLAYER_PLAYFROMSTART, kcPlaySongFromStart,  _T("&Play from Start") },
		{ ID_PLAYER_STOP,          kcStopSong,           _T("&Stop") },
		{ ID_PLAYER_PAUSE,         kcPauseSong,          _T("P&ause") },
		{ ID_MIDI_RECORD,          kcMidiRecord,         _T("&MIDI Record") },
		{ ID_ESTIMATESONGLENGTH,   kcEstimateSongLength, _T("&Estimate Song Length") },
		{ ID_APPROX_BPM,           kcApproxRealBPM,      _T("Approximate Real &BPM") },

		{ ID_EDIT_UNDO,                  kcEditUndo,      _T("&Undo") },
		{ ID_EDIT_REDO,                  kcEditRedo,      _T("&Redo") },
		{ ID_EDIT_CUT,                   kcEditCut,       _T("Cu&t") },
		{ ID_EDIT_COPY,                  kcEditCopy,      _T("&Copy") },
		{ ID_EDIT_PASTE,                 kcEditPaste,     _T("&Paste") },
		{ ID_EDIT_SELECT_ALL,            kcEditSelectAll, _T("Select &All") },
		{ ID_EDIT_CLEANUP,               kcNull,          _T("C&leanup") },
		{ ID_EDIT_FIND,                  kcEditFind,      _T("&Find / Replace") },
		{ ID_EDIT_FINDNEXT,              kcEditFindNext,  _T("Find &Next") },
		{ ID_EDIT_GOTO_MENU,             kcPatternGoto,   _T("&Goto") },
		{ ID_EDIT_SPLITKEYBOARDSETTINGS, kcShowSplitKeyboardSettings, _T("Split &Keyboard Settings") },
		// "Paste Special" sub menu
		{ ID_EDIT_PASTE_SPECIAL,    kcEditMixPaste,         _T("&Mix Paste") },
		{ ID_EDIT_MIXPASTE_ITSTYLE, kcEditMixPasteITStyle,  _T("M&ix Paste (IT Style)") },
		{ ID_EDIT_PASTEFLOOD,       kcEditPasteFlood,       _T("Paste Fl&ood") },
		{ ID_EDIT_PUSHFORWARDPASTE, kcEditPushForwardPaste, _T("&Push Forward Paste (Insert)") },

		{ ID_VIEW_GLOBALS,        kcViewGeneral,            _T("&General") },
		{ ID_VIEW_SAMPLES,        kcViewSamples,            _T("&Samples") },
		{ ID_VIEW_PATTERNS,       kcViewPattern,            _T("&Patterns") },
		{ ID_VIEW_INSTRUMENTS,    kcViewInstruments,        _T("&Instruments") },
		{ ID_VIEW_COMMENTS,       kcViewComments,           _T("&Comments") },
		{ ID_VIEW_OPTIONS,        kcViewOptions,            _T("S&etup") },
		{ ID_VIEW_TOOLBAR,        kcViewMain,               _T("&Main") },
		{ IDD_TREEVIEW,           kcViewTree,               _T("&Tree") },
		{ ID_PLUGIN_SETUP,        kcViewAddPlugin,          _T("Pl&ugin Manager") },
		{ ID_CHANNEL_MANAGER,     kcViewChannelManager,     _T("Ch&annel Manager") },
		{ ID_CLIPBOARD_MANAGER,   kcToggleClipboardManager, _T("C&lipboard Manager") },
		{ ID_VIEW_SONGPROPERTIES, kcViewSongProperties,     _T("Song P&roperties") },
		{ ID_PATTERN_MIDIMACRO,   kcShowMacroConfig,        _T("&Zxx Macro Configuration") },
		{ ID_VIEW_MIDIMAPPING,    kcViewMIDImapping,        _T("&MIDI Mapping") },
		{ ID_VIEW_EDITHISTORY,    kcViewEditHistory,        _T("Edit &History") },
		// Help submenu
		{ ID_HELPSHOW,        kcHelp, _T("&Help") },
		{ ID_EXAMPLE_MODULES, kcNull, _T("&Example Modules") },
	};

	for(const auto & [cmdID, command, text] : MenuItems)
	{
		if(id == cmdID)
		{
			if(command != kcNull)
				return GetKeyTextFromCommand(command, text);
			else
				return text;
		}
	}
	MPT_ASSERT_NOTREACHED();
	return _T("Unknown Item");
}


void CInputHandler::UpdateMainMenu()
{
	CMenu *pMenu = (CMainFrame::GetMainFrame())->GetMenu();
	if (!pMenu) return;

	pMenu->GetSubMenu(0)->ModifyMenu(0, MF_BYPOSITION | MF_STRING, 0, GetMenuText(ID_FILE_NEW));
	static constexpr int MenuItems[] =
	{
		ID_FILE_OPEN,
		ID_FILE_APPENDMODULE,
		ID_FILE_CLOSE,
		ID_FILE_SAVE,
		ID_FILE_SAVE_AS,
		ID_FILE_SAVEASWAVE,
		ID_FILE_SAVEMIDI,
		ID_FILE_SAVECOMPAT,
		ID_IMPORT_MIDILIB,
		ID_ADD_SOUNDBANK,

		ID_PLAYER_PLAY,
		ID_PLAYER_PLAYFROMSTART,
		ID_PLAYER_STOP,
		ID_PLAYER_PAUSE,
		ID_MIDI_RECORD,
		ID_ESTIMATESONGLENGTH,
		ID_APPROX_BPM,

		ID_EDIT_UNDO,
		ID_EDIT_REDO,
		ID_EDIT_CUT,
		ID_EDIT_COPY,
		ID_EDIT_PASTE,
		ID_EDIT_PASTE_SPECIAL,
		ID_EDIT_MIXPASTE_ITSTYLE,
		ID_EDIT_PASTEFLOOD,
		ID_EDIT_PUSHFORWARDPASTE,
		ID_EDIT_SELECT_ALL,
		ID_EDIT_FIND,
		ID_EDIT_FINDNEXT,
		ID_EDIT_GOTO_MENU,
		ID_EDIT_SPLITKEYBOARDSETTINGS,

		ID_VIEW_GLOBALS,
		ID_VIEW_SAMPLES,
		ID_VIEW_PATTERNS,
		ID_VIEW_INSTRUMENTS,
		ID_VIEW_COMMENTS,
		ID_VIEW_TOOLBAR,
		IDD_TREEVIEW,
		ID_VIEW_OPTIONS,
		ID_PLUGIN_SETUP,
		ID_CHANNEL_MANAGER,
		ID_CLIPBOARD_MANAGER,
		ID_VIEW_SONGPROPERTIES,
		ID_VIEW_SONGPROPERTIES,
		ID_PATTERN_MIDIMACRO,
		ID_VIEW_EDITHISTORY,
		ID_HELPSHOW,
	};
	for(const auto id : MenuItems)
	{
		pMenu->ModifyMenu(id, MF_BYCOMMAND | MF_STRING, id, GetMenuText(id));
	}
}


void CInputHandler::SetNewCommandSet(const CCommandSet *newSet)
{
	m_activeCommandSet->Copy(newSet);
	m_activeCommandSet->GenKeyMap(m_keyMap);
	SetupSpecialKeyInterception(); // Feature: use Windows keys as modifier keys, intercept special keys
	UpdateMainMenu();
}


bool CInputHandler::SetEffectLetters(const CModSpecifications &modSpecs)
{
	MPT_LOG_GLOBAL(LogDebug, "InputHandler", U_("Changing command set."));
	bool retval = m_activeCommandSet->QuickChange_SetEffects(modSpecs);
	if(retval) m_activeCommandSet->GenKeyMap(m_keyMap);
	return retval;
}


bool CInputHandler::IsKeyPressHandledByTextBox(DWORD key, HWND hWnd) const
{
	if(hWnd == nullptr)
		return false;
	
	TCHAR activeWindowClassName[6];
	GetClassName(hWnd, activeWindowClassName, mpt::saturate_cast<int>(std::size(activeWindowClassName)));
	const bool textboxHasFocus = _tcsicmp(activeWindowClassName, _T("Edit")) == 0;
	if(!textboxHasFocus)
		return false;

	//Alpha-numerics (only shift or no modifier):
	if(!GetModifierMask().test_any_except(ModShift)
		&&  ((key>='A'&&key<='Z') || (key>='0'&&key<='9') ||
		 key==VK_DIVIDE  || key==VK_MULTIPLY || key==VK_SPACE || key==VK_RETURN ||
		 key==VK_CAPITAL || (key>=VK_OEM_1 && key<=VK_OEM_3) || (key>=VK_OEM_4 && key<=VK_OEM_8)))
		return true;

	//navigation (any modifier):
	if(key == VK_LEFT || key == VK_RIGHT || key == VK_UP || key == VK_DOWN ||
		key == VK_HOME || key == VK_END || key == VK_DELETE || key == VK_INSERT || key == VK_BACK)
		return true;

	//Copy paste etc..
	if(GetModifierMask() == ModCtrl &&
		(key == 'Y' || key == 'Z' || key == 'X' ||  key == 'C' || key == 'V' || key == 'A'))
		return true;

	return false;
}


BypassInputHandler::BypassInputHandler()
{
	if(CMainFrame::GetInputHandler())
	{
		bypassed = true;
		CMainFrame::GetInputHandler()->Bypass(true);
	}
}


BypassInputHandler::~BypassInputHandler()
{
	if(bypassed)
	{
		CMainFrame::GetInputHandler()->Bypass(false);
		bypassed = false;
	}
}

OPENMPT_NAMESPACE_END