void
KeyboardRepeat::set(EventType eventType,
Flags flags,
ConsumerKeyCode key,
int delayUntilRepeat,
int keyRepeat) {
if (key == ConsumerKeyCode::VK_NONE) return;
if (eventType == EventType::UP) {
goto cancel;
} else if (eventType == EventType::DOWN) {
if (!key.isRepeatable()) {
goto cancel;
}
cancel();
primitive_add(eventType, flags, key);
primitive_start(delayUntilRepeat, keyRepeat);
IOLOG_DEVEL("KeyboardRepeat::set consumer key:%d flags:0x%x\n", key.get(), flags.get());
} else {
goto cancel;
}
return;
cancel:
cancel();
}
void
PressDownKeys::clear(void) {
IOLOG_DEVEL("PressDownKeys::clear list_.size = %d\n", static_cast<int>(list_.size()));
Item* p = static_cast<Item*>(list_.safe_front());
for (;;) {
if (!p) break;
Params_KeyboardEventCallBack params(EventType::UP, Flags(0), p->key, p->keyboardType, false);
EventOutputQueue::push(params);
IOLOG_DEVEL("PressDownKeys::clear key:%d, keyboardType:%d\n", params.key.get(), params.keyboardType.get());
p = static_cast<Item*>(list_.erase_and_delete(p));
}
}
size_t ListHookedDevice::pressingPhysicalKeysCountAll(void) {
size_t count = ListHookedKeyboard::instance().pressingPhysicalKeysCount() +
ListHookedConsumer::instance().pressingPhysicalKeysCount() +
ListHookedPointing::instance().pressingPhysicalKeysCount();
IOLOG_DEVEL("ListHookedDevice::pressingPhysicalKeysCountAll: %ld\n", count);
return count;
}
void
KeyboardRepeat::set(EventType eventType,
Flags flags,
ConsumerKeyCode key)
{
if (! queue_) return;
if (key == ConsumerKeyCode::VK_NONE) return;
if (eventType == EventType::UP) {
goto cancel;
} else if (eventType == EventType::DOWN) {
if (! key.isRepeatable()) {
goto cancel;
}
cancel();
primitive_add(eventType, flags, key);
primitive_start(Config::get_repeat_consumer_initial_wait(),
Config::get_repeat_consumer_wait());
IOLOG_DEVEL("KeyboardRepeat::set consumer key:%d flags:0x%x\n", key.get(), flags.get());
} else {
goto cancel;
}
return;
cancel:
cancel();
}
void
CommonData::setcurrent_workspacedata(void)
{
// ------------------------------------------------------------
// When we press the functional key (ex. F2) with the keyboard of the third vendor,
// KeyRemap4MacBook_client::sendmsg returns EIO.
//
// We use the previous value when the error occurred.
static KeyRemap4MacBook_bridge::GetWorkspaceData::Reply last = {
0,
0,
0,
};
int error = KeyRemap4MacBook_client::sendmsg(KeyRemap4MacBook_bridge::REQUEST_GET_WORKSPACE_DATA, NULL, 0, ¤t_workspacedata_, sizeof(current_workspacedata_));
IOLOG_DEVEL("GetWorkspaceData: type:%d, inputmode:%d, inputmodedetail:%d, error:%d\n",
current_workspacedata_.type,
current_workspacedata_.inputmode,
current_workspacedata_.inputmodedetail,
error);
if (error == 0) {
last = current_workspacedata_;
} else {
// use last info.
current_workspacedata_ = last;
}
}
void
PressDownKeys::add(KeyCode key, KeyboardType keyboardType) {
if (key == KeyCode::VK_NONE) return;
list_.push_back(new Item(key, keyboardType));
IOLOG_DEVEL("PressDownKeys::add key:%d, keyboardType:%d\n", key.get(), keyboardType.get());
}
void ListHookedDevice::erase(IOHIDevice* p) {
ListHookedDevice::Item* item = get(p);
if (!item) return;
list_.erase_and_delete(item);
IOLOG_DEVEL("ListHookedDevice::erase list_.size = %d\n", static_cast<int>(list_.size()));
refresh();
}
void
EventWatcher::on(void)
{
if (! list_) return;
IOLOG_DEVEL("EventWatcher::on (list_->size:%d)\n", static_cast<int>(list_->size()));
for (Item* p = static_cast<Item*>(list_->front()); p; p = static_cast<Item*>(p->getnext())) {
p->on();
}
}
void FlagStatus::log(void) const {
for (size_t i = 0; i < item_.size(); ++i) {
int sum = item_[i].sum(false);
if (sum != 0) {
const char* name = ModifierName::getName(item_[i].flag_);
if (name) {
IOLOG_DEVEL("FlagStatus %s: %d\n", name, sum);
}
}
}
}
void ListHookedDevice::push_back(ListHookedDevice::Item* newp) {
if (!newp) return;
last_ = newp->device_;
list_.push_back(newp);
IOLOG_DEVEL("ListHookedDevice::push_back list_.size = %d\n", static_cast<int>(list_.size()));
refresh();
start_refreshInProgressDevices_timer();
}
void
PressDownKeys::clear(void)
{
if (! list_) return;
IOLOG_DEVEL("PressDownKeys::clear list_->size = %d\n", static_cast<int>(list_->size()));
Item* p = static_cast<Item*>(list_->front());
for (;;) {
if (! p) break;
Params_KeyboardEventCallBack::auto_ptr ptr(Params_KeyboardEventCallBack::alloc(EventType::UP, Flags(0), p->key, p->keyboardType, false));
if (! ptr) break;
EventOutputQueue::push(*ptr);
IOLOG_DEVEL("PressDownKeys::clear key:%d, keyboardType:%d\n", (p->key).get(), (p->keyboardType).get());
p = static_cast<Item*>(list_->erase_and_delete(p));
}
}
void
ListHookedDevice::push_back(ListHookedDevice::Item* newp)
{
if (! list_) return;
if (! newp) return;
last_ = newp->device_;
list_->push_back(newp);
// Call reset whenever the device status is changed.
reset();
IOLOG_DEVEL("ListHookedDevice::push_back list_->size = %d\n", static_cast<int>(list_->size()));
refresh();
}
void
PressDownKeys::remove(KeyCode key, KeyboardType keyboardType) {
Item* p = static_cast<Item*>(list_.safe_front());
for (;;) {
if (!p) break;
if (p->key == key &&
p->keyboardType == keyboardType) {
p = static_cast<Item*>(list_.erase_and_delete(p));
} else {
p = static_cast<Item*>(p->getnext());
}
}
IOLOG_DEVEL("PressDownKeys::remove key:%d, keyboardType:%d\n", key.get(), keyboardType.get());
}
void
ListHookedDevice::erase(IOHIDevice* p)
{
if (! list_) return;
ListHookedDevice::Item* item = get(p);
if (! item) return;
list_->erase(item);
// Call reset whenever the device status is changed.
reset();
IOLOG_DEVEL("ListHookedDevice::erase list_->size = %d\n", static_cast<int>(list_->size()));
refresh();
}
void
KeyboardRepeat::set(EventType eventType,
Flags flags,
KeyCode key,
KeyboardType keyboardType,
int delayUntilRepeat,
int keyRepeat)
{
if (! queue_) return;
if (key == KeyCode::VK_NONE) return;
if (eventType == EventType::MODIFY) {
goto cancel;
} else if (eventType == EventType::UP) {
// The repetition of plural keys is controlled by manual operation.
// So, we ignore it.
if (queue_->size() != 1) return;
// We stop key repeat only when the repeating key is up.
KeyboardRepeat::Item* p = static_cast<KeyboardRepeat::Item*>(queue_->front());
if (p && (p->params).type == ParamsUnion::KEYBOARD) {
Params_KeyboardEventCallBack* params = (p->params).params.params_KeyboardEventCallBack;
if (params && key == params->key) {
goto cancel;
}
}
} else if (eventType == EventType::DOWN) {
cancel();
primitive_add(eventType, flags, key, keyboardType, Item::TYPE_NORMAL);
primitive_start(delayUntilRepeat, keyRepeat);
IOLOG_DEVEL("KeyboardRepeat::set key:%d flags:0x%x\n", key.get(), flags.get());
} else {
goto cancel;
}
return;
cancel:
cancel();
}
void
KeyboardRepeat::fire_timer_callback(OSObject* owner, IOTimerEventSource* sender) {
IOLOG_DEVEL("KeyboardRepeat::fire queue_.size = %d\n", static_cast<int>(queue_.size()));
// ----------------------------------------
for (KeyboardRepeat::Item* p = static_cast<KeyboardRepeat::Item*>(queue_.safe_front()); p; p = static_cast<KeyboardRepeat::Item*>(p->getnext())) {
{
{
auto params = (p->getParamsBase()).get_Params_KeyboardEventCallBack();
if (params) {
EventOutputQueue::FireKey::fire(
Params_KeyboardEventCallBack(
params->eventType,
params->flags,
params->key,
params->keyboardType,
queue_.size() == 1 ? true : false));
}
}
{
auto params = (p->getParamsBase()).get_Params_KeyboardSpecialEventCallback();
if (params) {
EventOutputQueue::FireConsumer::fire(
Params_KeyboardSpecialEventCallback(
params->eventType,
params->flags,
params->key,
queue_.size() == 1 ? true : false));
}
}
{
auto params = (p->getParamsBase()).get_Params_RelativePointerEventCallback();
if (params) {
EventOutputQueue::FireRelativePointer::fire(params->buttons, params->dx, params->dy);
}
}
}
}
fire_timer_.setTimeoutMS(keyRepeat_);
}
void KeyboardRepeat::set(EventType eventType,
Flags flags,
KeyCode key,
KeyboardType keyboardType,
int delayUntilRepeat,
int keyRepeat) {
if (key == KeyCode::VK_NONE) return;
if (eventType == EventType::MODIFY) {
goto cancel;
} else if (eventType == EventType::UP) {
// The repetition of multiple keys is controlled by manual operation.
// So, we ignore it.
if (queue_.size() != 1) return;
// We stop key repeat only when the repeating key is up.
KeyboardRepeat::Item* p = static_cast<KeyboardRepeat::Item*>(queue_.safe_front());
if (p) {
auto params = (p->getParamsBase()).get_Params_KeyboardEventCallBack();
if (params && key == params->key) {
goto cancel;
}
}
} else if (eventType == EventType::DOWN) {
cancel();
primitive_add(eventType, flags, key, keyboardType);
primitive_start(delayUntilRepeat, keyRepeat);
IOLOG_DEVEL("KeyboardRepeat::set key:%d flags:0x%x\n", key.get(), flags.get());
} else {
goto cancel;
}
return;
cancel:
cancel();
}
void
ListHookedDevice::erase(IOHIDevice* p)
{
IOLockWrapper::ScopedLock lk(list_lock_);
if (! lk) return;
if (! list_) return;
ListHookedDevice::Item* item = get_nolock(p);
if (! item) return;
list_->erase(item);
// Call reset whenever the device status is changed.
reset();
IOLOG_DEVEL("ListHookedDevice::erase list_->size = %d\n", static_cast<int>(list_->size()));
refresh_nolock();
}
static void setcurrent_lastsentevent(const Params_Base& newval) {
current_lastsentevent_.update(newval);
IOLOG_DEVEL("LastSentEvent: %s:0x%04x, %s\n",
(current_lastsentevent_.get_datatype() == BRIDGE_DATATYPE_KEYCODE
? "KeyCode"
: (current_lastsentevent_.get_datatype() == BRIDGE_DATATYPE_CONSUMERKEYCODE
? "ConsumerKeyCode"
: (current_lastsentevent_.get_datatype() == BRIDGE_DATATYPE_POINTINGBUTTON
? "PointingButton"
: (current_lastsentevent_.get_datatype() == BRIDGE_DATATYPE_SCROLLWHEEL
? "ScrollWheel"
: "Unknown")))),
current_lastsentevent_.get_value(),
(current_lastsentevent_.get_eventtype() == EventType::NONE
? "EventType::NONE"
: (current_lastsentevent_.get_eventtype() == EventType::DOWN
? "EventType::DOWN"
: (current_lastsentevent_.get_eventtype() == EventType::UP
? "EventType::UP"
: (current_lastsentevent_.get_eventtype() == EventType::MODIFY
? "EventType::MODIFY"
: "Unknown")))));
}
void
NumHeldDownKeys::log(void)
{
IOLOG_DEVEL("NumHeldDownKeys = %d\n", num_);
}
void
NumHeldDownKeys::reset(void)
{
IOLOG_DEVEL("NumHeldDownKeys::reset\n");
num_ = 0;
}
void
KeyboardRepeat::fire_timer_callback(OSObject* owner, IOTimerEventSource* sender)
{
if (! queue_) return;
IOLOG_DEVEL("KeyboardRepeat::fire queue_->size = %d\n", static_cast<int>(queue_->size()));
// ----------------------------------------
for (KeyboardRepeat::Item* p = static_cast<KeyboardRepeat::Item*>(queue_->front()); p; p = static_cast<KeyboardRepeat::Item*>(p->getnext())) {
switch ((p->params).type) {
case ParamsUnion::KEYBOARD:
{
Params_KeyboardEventCallBack* params = (p->params).params.params_KeyboardEventCallBack;
if (params) {
switch (p->type) {
case Item::TYPE_NORMAL:
{
Params_KeyboardEventCallBack::auto_ptr ptr(Params_KeyboardEventCallBack::alloc(params->eventType,
params->flags,
params->key,
params->keyboardType,
queue_->size() == 1 ? true : false));
if (ptr) {
EventOutputQueue::FireKey::fire(*ptr);
}
break;
}
case Item::TYPE_DOWNUP:
{
EventOutputQueue::FireKey::fire_downup(params->flags,
params->key,
params->keyboardType);
break;
}
}
}
break;
}
case ParamsUnion::KEYBOARD_SPECIAL:
{
Params_KeyboardSpecialEventCallback* params = (p->params).params.params_KeyboardSpecialEventCallback;
if (params) {
Params_KeyboardSpecialEventCallback::auto_ptr ptr(Params_KeyboardSpecialEventCallback::alloc(params->eventType,
params->flags,
params->key,
queue_->size() == 1 ? true : false));
if (ptr) {
EventOutputQueue::FireConsumer::fire(*ptr);
}
}
break;
}
case ParamsUnion::UPDATE_FLAGS:
case ParamsUnion::RELATIVE_POINTER:
case ParamsUnion::SCROLL_WHEEL:
case ParamsUnion::WAIT:
// do nothing
break;
}
}
fire_timer_.setTimeoutMS(keyRepeat_);
}
