steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/mptrack/InputHandler.cpp

633 lines
19 KiB
C++
Raw Blame History

/*
* 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
Reference in New Issue View Git Blame Copy Permalink