void GLFWCALL Application::keyCallback(int key, int action)
{
if(!stateStack_.empty())
{
if(action == GLFW_PRESS)
{
stateStack_.top()->onKeyPress(KeyCode(key));
}
else
{
stateStack_.top()->onKeyRelease(KeyCode(key));
}
}
// maintain a list of pressed keys
if(action == GLFW_PRESS)
{
pressedKeys_.push_back(static_cast<KeyCode>(key));
}
else
{
// delete a key from the vector
std::vector<KeyCode>::iterator it;
it = std::find(pressedKeys_.begin(), pressedKeys_.end(), key);
if(it != pressedKeys_.end())
{
pressedKeys_.erase(it);
}
}
}
void
DoublePressModifier::add(unsigned int datatype, unsigned int newval)
{
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE:
{
switch (index_) {
case 0:
// pass-through (== no break)
fromKey_.key = newval;
case 1:
keytokey_.add(KeyCode(newval));
break;
case 2:
// pass-through (== no break)
keytokey_fire_.add(KeyCode::VK_PSEUDO_KEY);
keytokey_fire_.add(fromKey_.flags);
default:
keytokey_fire_.add(KeyCode(newval));
break;
}
++index_;
break;
}
case BRIDGE_DATATYPE_FLAGS:
{
switch (index_) {
case 0:
IOLOG_ERROR("Invalid DoublePressModifier::add\n");
break;
case 1:
// pass-through (== no break)
fromKey_.flags = newval;
case 2:
keytokey_.add(Flags(newval));
break;
default:
keytokey_fire_.add(Flags(newval));
break;
}
break;
}
default:
IOLOG_ERROR("DoublePressModifier::add invalid datatype:%d\n", datatype);
break;
}
}
uint32_t
KeyboardEvent::Which()
{
// If this event is initialized with ctor, which can have independent value.
if (mInitializedByCtor) {
return mInitializedWhichValue;
}
switch (mEvent->message) {
case NS_KEY_BEFORE_DOWN:
case NS_KEY_DOWN:
case NS_KEY_AFTER_DOWN:
case NS_KEY_BEFORE_UP:
case NS_KEY_UP:
case NS_KEY_AFTER_UP:
return KeyCode();
case NS_KEY_PRESS:
//Special case for 4xp bug 62878. Try to make value of which
//more closely mirror the values that 4.x gave for RETURN and BACKSPACE
{
uint32_t keyCode = mEvent->AsKeyboardEvent()->keyCode;
if (keyCode == NS_VK_RETURN || keyCode == NS_VK_BACK) {
return keyCode;
}
return CharCode();
}
}
return 0;
}
uint32_t
KeyboardEvent::Which()
{
// If this event is initialized with ctor, which can have independent value.
if (mInitializedByCtor) {
return mInitializedWhichValue;
}
switch (mEvent->mMessage) {
case eBeforeKeyDown:
case eKeyDown:
case eKeyDownOnPlugin:
case eAfterKeyDown:
case eBeforeKeyUp:
case eKeyUp:
case eKeyUpOnPlugin:
case eAfterKeyUp:
return KeyCode();
case eKeyPress:
//Special case for 4xp bug 62878. Try to make value of which
//more closely mirror the values that 4.x gave for RETURN and BACKSPACE
{
uint32_t keyCode = mEvent->AsKeyboardEvent()->mKeyCode;
if (keyCode == NS_VK_RETURN || keyCode == NS_VK_BACK) {
return keyCode;
}
return CharCode();
}
default:
break;
}
return 0;
}
void KeyboardEvent::GetInitDict(KeyboardEventInit& aParam)
{
GetKey(aParam.mKey);
GetCode(aParam.mCode);
aParam.mLocation = Location();
aParam.mRepeat = Repeat();
aParam.mIsComposing = IsComposing();
// legacy attributes
aParam.mKeyCode = KeyCode();
aParam.mCharCode = CharCode();
aParam.mWhich = Which();
// modifiers from EventModifierInit
aParam.mCtrlKey = CtrlKey();
aParam.mShiftKey = ShiftKey();
aParam.mAltKey = AltKey();
aParam.mMetaKey = MetaKey();
WidgetKeyboardEvent* internalEvent = mEvent->AsKeyboardEvent();
aParam.mModifierAltGraph = internalEvent->IsAltGraph();
aParam.mModifierCapsLock = internalEvent->IsCapsLocked();
aParam.mModifierFn = internalEvent->IsFn();
aParam.mModifierFnLock = internalEvent->IsFnLocked();
aParam.mModifierNumLock = internalEvent->IsNumLocked();
aParam.mModifierOS = internalEvent->IsOS();
aParam.mModifierScrollLock = internalEvent->IsScrollLocked();
aParam.mModifierSymbol = internalEvent->IsSymbol();
aParam.mModifierSymbolLock = internalEvent->IsSymbolLocked();
// EventInit
aParam.mBubbles = internalEvent->mFlags.mBubbles;
aParam.mCancelable = internalEvent->mFlags.mCancelable;
}
void
ScrollWheelToKey::add(unsigned int datatype, unsigned int newval)
{
switch (datatype) {
case BRIDGE_DATATYPE_SCROLLWHEEL:
{
switch (index_) {
case 0:
fromScrollWheel_ = newval;
break;
default:
IOLOG_ERROR("Invalid ScrollWheelToKey::add\n");
break;
}
++index_;
break;
}
case BRIDGE_DATATYPE_KEYCODE:
{
switch (index_) {
case 0:
IOLOG_ERROR("Invalid ScrollWheelToKey::add\n");
break;
case 1:
// pass-through (== no break)
keytokey_.add(KeyCode::VK_PSEUDO_KEY);
keytokey_.add(fromFlags_);
default:
keytokey_.add(KeyCode(newval));
break;
}
++index_;
break;
}
case BRIDGE_DATATYPE_FLAGS:
{
switch (index_) {
case 0:
IOLOG_ERROR("Invalid ScrollWheelToKey::add\n");
break;
case 1:
fromFlags_ = newval;
break;
default:
keytokey_.add(Flags(newval));
break;
}
break;
}
default:
IOLOG_ERROR("ScrollWheelToKey::add invalid datatype:%d\n", datatype);
break;
}
}
//------------------------------------------------------------------------------------
void CameraPositionTool::initConstants()
{
ROOT_MENU_ID = "Tools";
ROOT_MENU_CAPTION = "#{Tools}";
POPUP_MENU_ID = "CameraPosition";
POPUP_MENU_CAPTION = "#{CameraPosition}";
MENU_SEPARATOR_ID[0] = "CameraPositionSep";
MENU_SEPARATOR_ID[1] = "CameraPositionSep2";
STORE_MENU_ITEM_DESC = "#{StoreCameraPosition_Desc}";
RESTORE_MENU_ITEM_DESC = "#{RestoreCameraPosition_Desc}";
for(size_t i = 0; i != NUM_POSITIONS; ++i)
{
String ip1 = StrConv::toString((i + 1) % NUM_POSITIONS);
POSITION_CONFIG_KEY_NAME[i] = "CameraPosition" + ip1;
ROTATION_CONFIG_KEY_NAME[i] = "CameraRotation" + ip1;
STORE_MENU_ITEM_ID[i] = "StoreCameraPosition" + ip1;
RESTORE_MENU_ITEM_ID[i] = "RestoreCameraPosition" + ip1;
STORE_MENU_ITEM_CAPTION[i] = "#{StoreCameraPosition}";
RESTORE_MENU_ITEM_CAPTION[i] = "#{RestoreCameraPosition}";
DEFAULT_STORE_HOTKEY[i] = KeyComb(KeyCode::LCONTROL, static_cast<KeyCode::Enum>(KeyCode::ONE + i));
DEFAULT_RESTORE_HOTKEY[i] = KeyCode(static_cast<KeyCode::Enum>(KeyCode::ONE + i));
STORE_HOTKEY_CONFIG_KEY_NAME[i] = "StoreCameraPosition" + ip1;
RESTORE_HOTKEY_CONFIG_KEY_NAME[i] = "RestoreCameraPosition" + ip1;
}
}
NS_IMETHODIMP
KeyboardEvent::GetKeyCode(uint32_t* aKeyCode)
{
NS_ENSURE_ARG_POINTER(aKeyCode);
*aKeyCode = KeyCode();
return NS_OK;
}
/**
Gets a character from the console.
@return the key code from the console.
*/
EXPORT_C TKeyCode CConsoleBase::Getch()
{
TRequestStatus s;
Read(s);
User::WaitForRequest(s);
__ASSERT_ALWAYS(s==KErrNone,Panic(EConsGetchFailed));
return(KeyCode());
}
void CSerialKeyboard::RunL()
{
TInt c=KeyCode();
if (c>=0)
{
// convert character to keycode and shift, func, ctrl status
TUint16 code = convertCode[c];
TBool isShifted = ISSHIFTED(code);
TBool isFunced = ISFUNCED(code);
TBool isCtrled = ISCTRLED(code);
TUint8 stdKey = STDKEY(code);
TRawEvent e;
// post it as a sequence of events
if (isShifted)
{
e.Set(TRawEvent::EKeyDown,EStdKeyRightShift,0);
UserSvr::AddEvent(e);
}
if (isCtrled)
{
e.Set(TRawEvent::EKeyDown,EStdKeyLeftCtrl,0);
UserSvr::AddEvent(e);
}
if (isFunced)
{
e.Set(TRawEvent::EKeyDown,EStdKeyLeftFunc,0);
UserSvr::AddEvent(e);
}
e.Set(TRawEvent::EKeyDown,stdKey,0);
UserSvr::AddEvent(e);
e.Set(TRawEvent::EKeyUp,stdKey,0);
UserSvr::AddEvent(e);
if (isFunced)
{
e.Set(TRawEvent::EKeyUp,EStdKeyLeftFunc,0);
UserSvr::AddEvent(e);
}
if (isCtrled)
{
e.Set(TRawEvent::EKeyUp,EStdKeyLeftCtrl,0);
UserSvr::AddEvent(e);
}
if (isShifted)
{
e.Set(TRawEvent::EKeyUp,EStdKeyRightShift,0);
UserSvr::AddEvent(e);
}
}
// get another key
GetKey();
}
const KeyCode getKeyForString(const String &str)
{
for (unsigned i = 0; i < NUM_KEYS; ++i)
{
if (strcmp(keysToString[i], str.c_str()) == 0)
return KeyCode(i);
}
return KEY_VOID;
}
ToEvent(unsigned int datatype, unsigned int v) {
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE:
type_ = Type::KEY;
key_ = KeyCode(v);
break;
case BRIDGE_DATATYPE_CONSUMERKEYCODE:
type_ = Type::CONSUMER_KEY;
consumer_ = ConsumerKeyCode(v);
break;
case BRIDGE_DATATYPE_POINTINGBUTTON:
type_ = Type::POINTING_BUTTON;
button_ = PointingButton(v);
break;
default:
IOLOG_ERROR("Unknown datatype: %d\n", datatype);
type_ = Type::NONE;
break;
}
}
uint32_t
nsDOMKeyboardEvent::Which()
{
switch (mEvent->message) {
case NS_KEY_UP:
case NS_KEY_DOWN:
return KeyCode();
case NS_KEY_PRESS:
//Special case for 4xp bug 62878. Try to make value of which
//more closely mirror the values that 4.x gave for RETURN and BACKSPACE
{
uint32_t keyCode = ((nsKeyEvent*)mEvent)->keyCode;
if (keyCode == NS_VK_RETURN || keyCode == NS_VK_BACK) {
return keyCode;
}
return CharCode();
}
}
return 0;
}
void
ConsumerToKey::add(unsigned int datatype, unsigned int newval)
{
switch (datatype) {
case BRIDGE_DATATYPE_CONSUMERKEYCODE:
{
switch (index_) {
case 0:
fromKey_.key = newval;
consumertoconsumer_.add(ConsumerKeyCode(newval));
consumertoconsumer_.add(ConsumerKeyCode::VK_NONE);
break;
default:
IOLOG_ERROR("Invalid ConsumerToKey::add\n");
break;
}
++index_;
break;
}
case BRIDGE_DATATYPE_KEYCODE:
{
switch (index_) {
case 0:
IOLOG_ERROR("Invalid ConsumerToKey::add\n");
break;
case 1:
// pass-through (== no break)
keytokey_.add(KeyCode::VK_PSEUDO_KEY);
keytokey_.add(fromKey_.flags);
default:
keytokey_.add(KeyCode(newval));
break;
}
++index_;
break;
}
case BRIDGE_DATATYPE_FLAGS:
{
switch (index_) {
case 0:
break;
case 1:
fromKey_.flags = newval;
break;
default:
keytokey_.add(Flags(newval));
break;
}
break;
}
default:
IOLOG_ERROR("ConsumerToKey::add invalid datatype:%d\n", datatype);
break;
}
}
void SimultaneousKeyPresses::add(AddDataType datatype, AddValue newval) {
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE:
case BRIDGE_DATATYPE_CONSUMERKEYCODE:
case BRIDGE_DATATYPE_POINTINGBUTTON: {
// ----------------------------------------
// The first data is virtualkey_.
if (index_ == 0) {
if (datatype != BRIDGE_DATATYPE_KEYCODE) {
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add\n");
return;
}
virtualkey_ = KeyCode(newval);
keytokey_.add(virtualkey_);
goto finish;
}
// ----------------------------------------
// From keys
if (!isFromInfoFull_) {
fromInfo_.push_back(FromInfo(datatype, newval));
if (isUseSeparator_ == false) {
if (index_ == 2) {
isFromInfoFull_ = true;
}
}
goto finish;
}
// ----------------------------------------
// To keys
if (keytokey_.toKeysSize() == 0 &&
datatype == BRIDGE_DATATYPE_KEYCODE) {
toKey_raw_ = KeyCode(newval);
}
keytokey_.add(datatype, newval);
finish:
++index_;
break;
}
case BRIDGE_DATATYPE_MODIFIERFLAG:
case BRIDGE_DATATYPE_MODIFIERFLAGS_END: {
if (index_ < 2) {
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add\n");
return;
} else {
if (keytokey_.toKeysSize() == 0) {
fromModifierFlags_.push_back(ModifierFlag(datatype, newval));
}
keytokey_.add(datatype, newval);
}
break;
}
case BRIDGE_DATATYPE_OPTION: {
Option option(newval);
if (Option::SIMULTANEOUSKEYPRESSES_RAW == option) {
isToRaw_ = true;
} else if (Option::SIMULTANEOUSKEYPRESSES_POST_FROM_EVENTS_AS_RAW == option) {
isPostFromEventsAsRaw_ = true;
} else if (Option::SIMULTANEOUSKEYPRESSES_STRICT_KEY_ORDER == option) {
isStrictKeyOrder_ = true;
} else if (Option::USE_SEPARATOR == option) {
isUseSeparator_ = true;
} else if (Option::SEPARATOR == option) {
isFromInfoFull_ = true;
} else if (Option::NOREPEAT == option ||
Option::KEYTOKEY_BEFORE_KEYDOWN == option ||
Option::KEYTOKEY_AFTER_KEYUP == option) {
keytokey_.add(option);
} else {
IOLOG_ERROR("SimultaneousKeyPresses::add unknown option:%u\n", static_cast<unsigned int>(newval));
}
break;
}
case BRIDGE_DATATYPE_DELAYUNTILREPEAT:
case BRIDGE_DATATYPE_KEYREPEAT: {
keytokey_.add(datatype, newval);
break;
}
default:
IOLOG_ERROR("SimultaneousKeyPresses::add invalid datatype:%u\n", static_cast<unsigned int>(datatype));
break;
}
}
void
KeyOverlaidModifier::add(unsigned int datatype, unsigned int newval)
{
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE:
{
switch (index_) {
case 0:
keytokey_.add(KeyCode(newval));
keytokey_fire_.add(KeyCode::VK_PSEUDO_KEY);
break;
case 1:
toKey_.key = newval;
keytokey_.add(KeyCode(newval));
break;
default:
keytokey_fire_.add(KeyCode(newval));
break;
}
++index_;
break;
}
case BRIDGE_DATATYPE_FLAGS:
{
switch (index_) {
case 0:
IOLOG_ERROR("Invalid KeyOverlaidModifier::add\n");
break;
case 1:
keytokey_.add(Flags(newval));
break;
case 2:
toKey_.flags = newval;
keytokey_.add(Flags(newval));
break;
default:
keytokey_fire_.add(Flags(newval));
break;
}
break;
}
case BRIDGE_DATATYPE_OPTION:
{
if (Option::KEYOVERLAIDMODIFIER_REPEAT == newval) {
isRepeatEnabled_ = true;
} else {
IOLOG_ERROR("KeyOverlaidModifier::add unknown option:%d\n", newval);
}
break;
}
default:
IOLOG_ERROR("KeyOverlaidModifier::add invalid datatype:%d\n", datatype);
break;
}
}
// ======================================================================
void EventInputQueue::push_KeyboardEventCallback(OSObject* target,
unsigned int eventType,
unsigned int flags,
unsigned int key,
unsigned int charCode,
unsigned int charSet,
unsigned int origCharCode,
unsigned int origCharSet,
unsigned int keyboardType,
bool repeat,
AbsoluteTime ts,
OSObject* sender,
void* refcon) {
GlobalLock::ScopedLock lk;
if (!lk) return;
Params_KeyboardEventCallBack::log(true, EventType(eventType), Flags(flags), KeyCode(key), KeyboardType(keyboardType), repeat);
// ------------------------------------------------------------
// Ignore unknown modifiers
//
// You can confirm an unknown modifier by setting key code to 255 on Seil.
// This event also will be sent by Fn key on Leopold FC660M.
//
// KeyboardEventCallback [ caught]: eventType 12, flags 0x80000000, key 0x00ff, kbdType 43, repeat = 0
//
// This key sends the same event at key pressing and key releasing.
// Therefore, we cannot recognize whether key is pressed or key is released.
// So, we have to ignore this key for PressingPhysicalKeys.
//
if (EventType::MODIFY == EventType(eventType)) {
if (KeyCode(key).getModifierFlag() == ModifierFlag::ZERO) {
IOLOG_DEBUG("An unknown modifier is pressed (KeyCode:0x%x, Flags:0x%x). Ignore it.\n", key, flags);
return;
}
}
// ------------------------------------------------------------
KeyboardType newkeyboardtype(keyboardType);
RemapClassManager::remap_setkeyboardtype(newkeyboardtype);
KeyCode newkey(key);
Flags newflags(flags);
KeyCode::normalizeKey(newkey, newflags, EventType(eventType), newkeyboardtype);
// ------------------------------------------------------------
Params_KeyboardEventCallBack params(EventType(eventType),
newflags,
newkey,
CharCode(charCode),
CharSet(charSet),
OrigCharCode(origCharCode),
OrigCharSet(origCharSet),
newkeyboardtype,
repeat);
// ------------------------------------------------------------
IOHIKeyboard* device = OSDynamicCast(IOHIKeyboard, sender);
if (!device) return;
ListHookedKeyboard::Item* item = static_cast<ListHookedKeyboard::Item*>(ListHookedKeyboard::instance().get(device));
if (!item) return;
// ------------------------------------------------------------
// Device Hacks
// Drop events if "Disable an internal keyboard while external keyboards are connected" is enabled.
if (Config::get_essential_config(BRIDGE_ESSENTIAL_CONFIG_INDEX_general_disable_internal_keyboard_if_external_keyboard_exsits)) {
if (item->isInternalDevice() &&
ListHookedKeyboard::instance().isExternalDevicesConnected()) {
return;
}
}
// Logitech Cordless Presenter (LCP) Hack
//
// When an LCP is first plugged in, it will send a CONTROL_L down event
// when the first pageup/pagedown key is pressed without sending a corresponding
// up event -- effectively rendering the device (and the Mac) useless until it is
// unplugged from the system.
//
// Similarly, when the volume keys are first pressed, a SHIFT_L down event
// is generated, with now up event.
//
// This code effectively throws these events away if they are received from an LCP.
//
// *** LCP has 6 keys (Page Up, Page Down, a 'B' key, an 'Esc' key, and volume up / down keys). ***
// *** So, we can drop CONTROL_L and SHIFT_L without a problem. ***
if ((item->getDeviceIdentifier()).isEqualVendorProduct(DeviceVendor::LOGITECH, DeviceProduct::LOGITECH_CORDLESS_PRESENTER)) {
if (params.key == KeyCode::CONTROL_L) return;
if (params.key == KeyCode::SHIFT_L) return;
}
// ------------------------------------------------------------
// NumLock Hacks
//
// As for some keypads, NumLock is off when it was connected.
// We need to call setAlphaLock(true) to activate a device.
RemapClassManager::remap_forcenumlockon(item);
// ------------------------------------------------------------
CommonData::setcurrent_ts(ts);
// ------------------------------------------------------------
// Because we handle the key repeat ourself, drop the key repeat by hardware.
if (repeat) return;
// ------------------------------------------------------------
bool retainFlagStatusTemporaryCount = false;
bool push_back = true;
bool isSimultaneousKeyPressesTarget = true;
enqueue_(params, retainFlagStatusTemporaryCount, item->getDeviceIdentifier(), push_back, isSimultaneousKeyPressesTarget);
setTimer();
}
void
SimultaneousKeyPresses::add(unsigned int datatype, unsigned int newval)
{
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE:
case BRIDGE_DATATYPE_POINTINGBUTTON:
{
// ----------------------------------------
// The first data is virtualkey_.
if (index_ == 0) {
if (datatype != BRIDGE_DATATYPE_KEYCODE) {
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add\n");
return;
}
virtualkey_ = newval;
goto finish;
}
// ----------------------------------------
// From keys
if (! isFromInfoFull_) {
FromInfo fi;
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE: fi.set(KeyCode(newval)); break;
case BRIDGE_DATATYPE_POINTINGBUTTON: fi.set(PointingButton(newval)); break;
default:
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add unknown datatype\n");
return;
}
fromInfo_.push_back(fi);
if (isUseSeparator_ == false) {
if (index_ == 2) {
isFromInfoFull_ = true;
}
}
goto finish;
}
// ----------------------------------------
// To keys
{
ToType type = TOTYPE_NONE;
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE: type = TOTYPE_KEY; break;
case BRIDGE_DATATYPE_POINTINGBUTTON: type = TOTYPE_BUTTON; break;
default:
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add unknown datatype\n");
return;
}
if (toType_ == TOTYPE_NONE) {
toType_ = type;
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE:
keytokey_.add(virtualkey_);
keytokey_.add(fromFlags_);
toKey_raw_ = newval;
break;
case BRIDGE_DATATYPE_POINTINGBUTTON:
keytopointingbutton_.add(virtualkey_);
keytopointingbutton_.add(fromFlags_);
break;
default:
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add unknown datatype\n");
return;
}
}
if (toType_ != type) {
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add\n");
return;
}
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE:
keytokey_.add(KeyCode(newval));
break;
case BRIDGE_DATATYPE_POINTINGBUTTON:
keytopointingbutton_.add(PointingButton(newval));
break;
default:
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add unknown datatype\n");
return;
}
}
finish:
++index_;
break;
}
case BRIDGE_DATATYPE_FLAGS:
{
if (index_ < 2) {
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add\n");
return;
} else if (toType_ == TOTYPE_NONE) {
fromFlags_ = newval;
} else {
switch (toType_) {
case TOTYPE_KEY:
keytokey_.add(Flags(newval));
break;
case TOTYPE_BUTTON:
keytopointingbutton_.add(Flags(newval));
break;
default:
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add unknown datatype\n");
return;
}
}
break;
}
case BRIDGE_DATATYPE_OPTION:
{
if (Option::SIMULTANEOUSKEYPRESSES_RAW == newval) {
if (toType_ != TOTYPE_KEY) {
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add\n");
} else {
isToRaw_ = true;
}
} else if (Option::SIMULTANEOUSKEYPRESSES_STRICT_KEY_ORDER == newval) {
isStrictKeyOrder_ = true;
} else if (Option::USE_SEPARATOR == newval) {
isUseSeparator_ = true;
} else if (Option::SEPARATOR == newval) {
isFromInfoFull_ = true;
} else if (Option::NOREPEAT == newval ||
Option::KEYTOKEY_BEFORE_KEYDOWN == newval ||
Option::KEYTOKEY_AFTER_KEYUP == newval) {
if (toType_ != TOTYPE_KEY) {
IOLOG_ERROR("Invalid SimultaneousKeyPresses::add\n");
} else {
keytokey_.add(Option(newval));
}
} else {
IOLOG_ERROR("SimultaneousKeyPresses::add unknown option:%d\n", newval);
}
break;
}
default:
IOLOG_ERROR("SimultaneousKeyPresses::add invalid datatype:%d\n", datatype);
break;
}
}
FromEvent(AddDataType datatype, AddValue v) : isPressing_(false) {
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE: type_ = Type::KEY; key_ = KeyCode(v); break;
case BRIDGE_DATATYPE_CONSUMERKEYCODE: type_ = Type::CONSUMER_KEY; consumer_ = ConsumerKeyCode(v); break;
case BRIDGE_DATATYPE_POINTINGBUTTON: type_ = Type::POINTING_BUTTON; button_ = PointingButton(v); break;
default:
IOLOG_ERROR("Unknown datatype: %u\n", static_cast<unsigned int>(datatype));
type_ = Type::NONE;
break;
}
}
void
KeyOverlaidModifier::add(unsigned int datatype, unsigned int newval)
{
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE:
{
switch (index_) {
case 0:
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::FROM, datatype, newval);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::SHORT_PERIOD, KeyCode::VK_PSEUDO_KEY);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::LONG_PERIOD, KeyCode::VK_PSEUDO_KEY);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::LONG_LONG_PERIOD, KeyCode::VK_PSEUDO_KEY);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::PRESSING_TARGET_KEY_ONLY, KeyCode::VK_PSEUDO_KEY);
fromKeyFlag_ = KeyCode(newval).getModifierFlag();
break;
default:
if (! isUseSeparator_ && index_ >= 2) {
index_is_holding_ = false;
}
if (index_is_holding_) {
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::FROM, KeyCode::VK_NONE);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::LONG_PERIOD, datatype, newval);
} else {
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::SHORT_PERIOD, datatype, newval);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::LONG_LONG_PERIOD, datatype, newval);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::PRESSING_TARGET_KEY_ONLY, datatype, newval);
}
break;
}
++index_;
break;
}
case BRIDGE_DATATYPE_FLAGS:
{
switch (index_) {
case 0:
IOLOG_ERROR("Invalid KeyOverlaidModifier::add\n");
break;
case 1:
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::FROM, datatype, newval);
{
Flags flags(newval);
if (fromKeyFlag_ != ModifierFlag::NONE) {
flags.remove(fromKeyFlag_);
}
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::SHORT_PERIOD, flags);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::LONG_PERIOD, flags);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::LONG_LONG_PERIOD, flags);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::PRESSING_TARGET_KEY_ONLY, flags);
}
break;
default:
if (index_is_holding_) {
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::LONG_PERIOD, datatype, newval);
} else {
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::SHORT_PERIOD, datatype, newval);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::LONG_LONG_PERIOD, datatype, newval);
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::PRESSING_TARGET_KEY_ONLY, datatype, newval);
}
break;
}
break;
}
case BRIDGE_DATATYPE_OPTION:
{
Option option(newval);
if (Option::KEYOVERLAIDMODIFIER_REPEAT == option) {
dppkeytokey_.setPeriodMS(DependingPressingPeriodKeyToKey::PeriodMS::Mode::KEY_OVERLAID_MODIFIER_WITH_REPEAT);
} else if (Option::USE_SEPARATOR == option) {
isUseSeparator_ = true;
} else if (Option::SEPARATOR == option) {
if (index_ >= 2) {
index_is_holding_ = false;
}
} else if (Option::NOREPEAT == option ||
Option::KEYTOKEY_BEFORE_KEYDOWN == option ||
Option::KEYTOKEY_AFTER_KEYUP == option) {
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::LONG_PERIOD, datatype, newval);
} else {
IOLOG_ERROR("KeyOverlaidModifier::add unknown option:%d\n", newval);
}
break;
}
case BRIDGE_DATATYPE_DELAYUNTILREPEAT:
case BRIDGE_DATATYPE_KEYREPEAT:
{
dppkeytokey_.add(DependingPressingPeriodKeyToKey::KeyToKeyType::LONG_PERIOD, datatype, newval);
break;
}
default:
IOLOG_ERROR("KeyOverlaidModifier::add invalid datatype:%d\n", datatype);
break;
}
}
void HoldingKeyToKey::add(AddDataType datatype, AddValue newval) {
switch (datatype) {
case BRIDGE_DATATYPE_KEYCODE:
case BRIDGE_DATATYPE_CONSUMERKEYCODE:
case BRIDGE_DATATYPE_POINTINGBUTTON: {
switch (index_) {
case 0:
fromEvent_ = FromEvent(datatype, newval);
dppkeytokey_.setFromEvent(fromEvent_);
break;
default:
if (!isUseSeparator_ &&
datatype == BRIDGE_DATATYPE_KEYCODE &&
KeyCode::VK_NONE == KeyCode(newval) &&
indexType_ == INDEX_IS_NORMAL) {
indexType_ = INDEX_IS_HOLDING;
} else {
addToDependingPressingPeriodKeyToKey(datatype, newval);
}
break;
}
++index_;
break;
}
case BRIDGE_DATATYPE_MODIFIERFLAG:
case BRIDGE_DATATYPE_MODIFIERFLAGS_END:
case BRIDGE_DATATYPE_OPTION:
case BRIDGE_DATATYPE_DELAYUNTILREPEAT:
case BRIDGE_DATATYPE_KEYREPEAT: {
switch (index_) {
case 0:
if (datatype == BRIDGE_DATATYPE_OPTION && Option::USE_SEPARATOR == Option(newval)) {
isUseSeparator_ = true;
} else {
IOLOG_ERROR("Invalid HoldingKeyToKey::add\n");
}
break;
case 1: {
if (datatype == BRIDGE_DATATYPE_MODIFIERFLAG ||
datatype == BRIDGE_DATATYPE_MODIFIERFLAGS_END) {
dppkeytokey_.addFromModifierFlags(datatype, newval);
}
break;
}
default:
if (datatype == BRIDGE_DATATYPE_OPTION && Option::SEPARATOR == Option(newval)) {
if (index_ >= 2 &&
indexType_ == INDEX_IS_NORMAL) {
indexType_ = INDEX_IS_HOLDING;
}
} else if (datatype == BRIDGE_DATATYPE_OPTION && Option::KEYTOKEY_BEFORE_KEYDOWN == Option(newval)) {
indexType_ = INDEX_IS_KEYTOKEY_BEFORE_KEYDOWN;
dppkeytokey_.addBeforeAfterKeys(datatype, newval);
} else if (datatype == BRIDGE_DATATYPE_OPTION && Option::KEYTOKEY_AFTER_KEYUP == Option(newval)) {
indexType_ = INDEX_IS_KEYTOKEY_AFTER_KEYUP;
dppkeytokey_.addBeforeAfterKeys(datatype, newval);
} else {
addToDependingPressingPeriodKeyToKey(datatype, newval);
}
break;
}
break;
}
case BRIDGE_DATATYPE_THRESHOLDMILLISECOND:
dppkeytokey_.overwritePeriodMS(DependingPressingPeriodKeyToKey::PeriodMS::Mode::HOLDING_KEY_TO_KEY,
DependingPressingPeriodKeyToKey::PeriodMS::Type::SHORT_PERIOD,
newval);
break;
default:
IOLOG_ERROR("HoldingKeyToKey::add invalid datatype:%u\n", static_cast<unsigned int>(datatype));
break;
}
}
