bool
KeyOverlaidModifier::remap(RemapParams& remapParams)
{
bool savedIsAnyEventHappen = isAnyEventHappen_;
bool result = keytokey_.remap(remapParams);
if (! result) return false;
// ------------------------------------------------------------
if (remapParams.params.ex_iskeydown) {
EventWatcher::set(isAnyEventHappen_);
ic_.begin();
// ----------------------------------------
// We store the flags when KeyDown.
// Because it lets you make a natural input when the following sequence.
//
// ex. "Space to Shift (when type only, send Space)"
// (1) KeyDown Command_L
// (2) KeyDown Space save flags (Command_L)
// (3) KeyUp Command_L
// (4) KeyUp Space fire Command_L+Space
FlagStatus::temporary_decrease(toKey_.flags | toKey_.key.getModifierFlag() | Handle_VK_LAZY::getModifierFlag(toKey_.key));
savedflags_ = FlagStatus::makeFlags();
FlagStatus::temporary_increase(toKey_.flags | toKey_.key.getModifierFlag() | Handle_VK_LAZY::getModifierFlag(toKey_.key));
// ----------------------------------------
if (isRepeatEnabled_) {
target_ = this;
isfirenormal_ = false;
isfirerepeat_ = false;
firerepeat_timer_.setTimeoutMS(Config::get_keyoverlaidmodifier_initial_wait());
}
} else {
firerepeat_timer_.cancelTimeout();
if (isfirerepeat_) {
FlagStatus::ScopedTemporaryFlagsChanger stfc(savedflags_);
keytokey_fire_.call_remap_with_VK_PSEUDO_KEY(EventType::UP);
} else {
isfirenormal_ = true;
if (savedIsAnyEventHappen == false) {
int timeout = Config::get_essential_config(BRIDGE_ESSENTIAL_CONFIG_INDEX_parameter_keyoverlaidmodifier_timeout);
if (timeout <= 0 || ic_.checkThreshold(timeout) == false) {
FlagStatus::ScopedTemporaryFlagsChanger stfc(savedflags_);
keytokey_fire_.call_remap_with_VK_PSEUDO_KEY(EventType::DOWN);
keytokey_fire_.call_remap_with_VK_PSEUDO_KEY(EventType::UP);
}
}
EventWatcher::unset(isAnyEventHappen_);
}
}
return true;
}
void
DependingPressingPeriodKeyToKey::fire_timer_callback(OSObject* owner, IOTimerEventSource* sender)
{
if (! target_) return;
switch (target_->periodtype_) {
case PeriodType::NONE:
{
target_->periodtype_ = PeriodType::LONG_PERIOD;
FlagStatus::ScopedTemporaryFlagsChanger stfc(target_->savedflags_);
(target_->keytokey_[KeyToKeyType::LONG_PERIOD]).call_remap_with_VK_PSEUDO_KEY(EventType::DOWN);
target_->keyboardRepeatID_ = KeyboardRepeat::getID();
EventWatcher::set(target_->isAnyEventHappen_);
(target_->ic_).begin();
if (target_->periodMS_.enabled(PeriodMS::Type::LONG_LONG_PERIOD)) {
fire_timer_.setTimeoutMS(target_->periodMS_.get(PeriodMS::Type::LONG_LONG_PERIOD));
}
break;
}
case PeriodType::LONG_PERIOD:
{
// If keyboard repeat is canceled while pressing LONG_PERIOD key,
// we cancel LONG_LONG_PERIOD event.
bool isKeyboardRepeatCanceled = (target_->keyboardRepeatID_ != KeyboardRepeat::getID());
(target_->keytokey_[KeyToKeyType::LONG_PERIOD]).call_remap_with_VK_PSEUDO_KEY(EventType::UP);
if (isKeyboardRepeatCanceled) {
target_->periodtype_ = PeriodType::NONE;
} else {
target_->periodtype_ = PeriodType::LONG_LONG_PERIOD;
FlagStatus::ScopedTemporaryFlagsChanger stfc(target_->savedflags_);
(target_->keytokey_[KeyToKeyType::LONG_LONG_PERIOD]).call_remap_with_VK_PSEUDO_KEY(EventType::DOWN);
}
break;
}
case PeriodType::SHORT_PERIOD:
case PeriodType::LONG_LONG_PERIOD:
// do nothing
break;
}
}
void
DependingPressingPeriodKeyToKey::dokeydown(void)
{
if (! active_) return;
active_ = false;
if (target_ == this) {
fire_timer_.cancelTimeout();
}
switch (periodtype_) {
case PeriodType::NONE:
{
periodtype_ = PeriodType::SHORT_PERIOD;
FlagStatus::ScopedTemporaryFlagsChanger stfc(savedflags_);
keytokey_[KeyToKeyType::SHORT_PERIOD].call_remap_with_VK_PSEUDO_KEY(EventType::DOWN);
break;
}
case PeriodType::SHORT_PERIOD:
case PeriodType::LONG_PERIOD:
case PeriodType::LONG_LONG_PERIOD:
// do nothing
break;
}
}
void
KeyOverlaidModifier::firerepeat_timer_callback(OSObject* owner, IOTimerEventSource* sender)
{
if (! target_) return;
if (target_->isAnyEventHappen_) return;
if (! target_->isfirenormal_) {
target_->isfirerepeat_ = true;
FlagStatus::ScopedTemporaryFlagsChanger stfc(target_->savedflags_);
(target_->keytokey_fire_).call_remap_with_VK_PSEUDO_KEY(EventType::DOWN);
}
}
void
ToEvent::fire_downup(Flags flags, bool add_to_keyrepeat)
{
switch (type_) {
case Type::NONE:
break;
case Type::KEY:
{
KeyboardType keyboardType = CommonData::getcurrent_keyboardType();
EventOutputQueue::FireKey::fire_downup(flags, key_, keyboardType);
if (add_to_keyrepeat) {
KeyboardRepeat::primitive_add_downup(flags, key_, keyboardType);
}
break;
}
case Type::CONSUMER_KEY:
{
EventOutputQueue::FireConsumer::fire_downup(flags, consumer_);
if (add_to_keyrepeat) {
KeyboardRepeat::primitive_add(EventType::DOWN, flags, consumer_);
KeyboardRepeat::primitive_add(EventType::UP, flags, consumer_);
}
break;
}
case Type::POINTING_BUTTON:
{
FlagStatus::ScopedTemporaryFlagsChanger stfc(FlagStatus::globalFlagStatus(), flags);
for (int i = 0; i < 2; ++i) {
if (i == 0) {
ButtonStatus::increase(button_);
} else {
ButtonStatus::decrease(button_);
}
Buttons buttons(ButtonStatus::makeButtons());
EventOutputQueue::FireRelativePointer::fire(buttons);
if (add_to_keyrepeat) {
KeyboardRepeat::primitive_add(buttons);
}
}
break;
}
}
}
void
DependingPressingPeriodKeyToKey::dokeyup(void)
{
switch (periodtype_) {
case PeriodType::SHORT_PERIOD:
{
periodtype_ = PeriodType::NONE;
keytokey_[KeyToKeyType::SHORT_PERIOD].call_remap_with_VK_PSEUDO_KEY(EventType::UP);
break;
}
case PeriodType::LONG_PERIOD:
{
periodtype_ = PeriodType::NONE;
keytokey_[KeyToKeyType::LONG_PERIOD].call_remap_with_VK_PSEUDO_KEY(EventType::UP);
// ----------------------------------------
// handle PRESSING_TARGET_KEY_ONLY
if (periodMS_.enabled(PeriodMS::Type::PRESSING_TARGET_KEY_ONLY)) {
if (! isAnyEventHappen_ &&
ic_.getmillisec() < periodMS_.get(PeriodMS::Type::PRESSING_TARGET_KEY_ONLY)) {
FlagStatus::ScopedTemporaryFlagsChanger stfc(savedflags_);
keytokey_[KeyToKeyType::PRESSING_TARGET_KEY_ONLY].call_remap_with_VK_PSEUDO_KEY(EventType::DOWN);
keytokey_[KeyToKeyType::PRESSING_TARGET_KEY_ONLY].call_remap_with_VK_PSEUDO_KEY(EventType::UP);
}
}
break;
}
case PeriodType::LONG_LONG_PERIOD:
{
periodtype_ = PeriodType::NONE;
keytokey_[KeyToKeyType::LONG_LONG_PERIOD].call_remap_with_VK_PSEUDO_KEY(EventType::UP);
break;
}
case PeriodType::NONE:
// do nothing
break;
}
EventWatcher::unset(isAnyEventHappen_);
}
void
EventOutputQueue::FireKey::fire_downup(Flags flags, KeyCode key, KeyboardType keyboardType)
{
ModifierFlag f = key.getModifierFlag();
if (f != ModifierFlag::ZERO) {
FlagStatus::ScopedTemporaryFlagsChanger stfc(FlagStatus::globalFlagStatus(), flags);
// We operate FlagStatus for the case "key == KeyCode::CAPSLOCK".
FlagStatus::globalFlagStatus().increase(f);
{
Params_KeyboardEventCallBack::auto_ptr ptr(Params_KeyboardEventCallBack::alloc(EventType::MODIFY,
FlagStatus::globalFlagStatus().makeFlags(),
key,
keyboardType,
false));
if (! ptr) return;
FireKey::fire(*ptr);
}
FlagStatus::globalFlagStatus().decrease(f);
{
Params_KeyboardEventCallBack::auto_ptr ptr(Params_KeyboardEventCallBack::alloc(EventType::MODIFY,
FlagStatus::globalFlagStatus().makeFlags(),
key,
keyboardType,
false));
if (! ptr) return;
FireKey::fire(*ptr);
}
} else {
{
Params_KeyboardEventCallBack::auto_ptr ptr(Params_KeyboardEventCallBack::alloc(EventType::DOWN, flags, key, keyboardType, false));
if (! ptr) return;
FireKey::fire(*ptr);
}
{
Params_KeyboardEventCallBack::auto_ptr ptr(Params_KeyboardEventCallBack::alloc(EventType::UP, flags, key, keyboardType, false));
if (! ptr) return;
FireKey::fire(*ptr);
}
}
}
