void KeyCode::reverseNormalizeKey(KeyCode& key, Flags& flags, EventType eventType, KeyboardType keyboardType) { if (! Config::get_essential_config(BRIDGE_ESSENTIAL_CONFIG_INDEX_general_disable_numpad_hack)) { for (unsigned int i = 0; i < sizeof(fnkeyhack) / sizeof(fnkeyhack[0]); ++i) { if (fnkeyhack[i].reverse(key, flags, eventType)) break; } } if (keyboardType == KeyboardType::POWERBOOK || keyboardType == KeyboardType::POWERBOOK_G4 || keyboardType == KeyboardType::POWERBOOK_G4_TI) { if (key == KeyCode::ENTER) { key = KeyCode::ENTER_POWERBOOK; } } // ------------------------------------------------------------ // Don't add ModifierFlag::FN automatically for F-keys, PageUp/PageDown/Home/End and Forward Delete. // // PageUp/PageDown/Home/End and Forward Delete are entered by fn+arrow, fn+delete normally, // And, from Cocoa Application, F-keys and PageUp,... keys have Fn modifier // even if Fn key is not pressed actually. // So, it's natural adding ModifierFlag::FN to these keys. // However, there is a reason we must not add ModifierFlag::FN to there keys. // // Mission Control may have "fn" as shortcut key. // If we add ModifierFlag::FN here, // "XXX to PageUp" launches Mission Control because Mission Control recognizes fn key was pressed. // // It's not intended behavior from users. // Therefore, we don't add ModifierFlag::FN for these keys. // ------------------------------------------------------------ // set ModifierFlag::KEYPAD, ModifierFlag::CURSOR flags.stripCURSOR().stripKEYPAD(); // Note: KEYPAD_CLEAR, KEYPAD_COMMA have no ModifierFlag::KEYPAD bit. if (key == KeyCode::KEYPAD_0 || key == KeyCode::KEYPAD_1 || key == KeyCode::KEYPAD_2 || key == KeyCode::KEYPAD_3 || key == KeyCode::KEYPAD_4 || key == KeyCode::KEYPAD_5 || key == KeyCode::KEYPAD_6 || key == KeyCode::KEYPAD_7 || key == KeyCode::KEYPAD_8 || key == KeyCode::KEYPAD_9 || key == KeyCode::KEYPAD_DOT || key == KeyCode::KEYPAD_MULTIPLY || key == KeyCode::KEYPAD_PLUS || key == KeyCode::KEYPAD_SLASH || key == KeyCode::KEYPAD_MINUS || key == KeyCode::KEYPAD_EQUAL) { flags.add(ModifierFlag::KEYPAD); } if (key == KeyCode::CURSOR_UP || key == KeyCode::CURSOR_DOWN || key == KeyCode::CURSOR_LEFT || key == KeyCode::CURSOR_RIGHT) { flags.add(ModifierFlag::CURSOR); } }
TEST(Flags, add) { Flags mask = ModifierFlag::SHIFT_L | ModifierFlag::CONTROL_R | ModifierFlag::COMMAND_R; Flags flags = mask; EXPECT_EQ(mask, flags.stripFN()); flags.add(ModifierFlag::OPTION_L); EXPECT_EQ(mask | ModifierFlag::OPTION_L, flags); flags.add(ModifierFlag::NONE); EXPECT_EQ(mask | ModifierFlag::OPTION_L | ModifierFlag::NONE, flags); }
TEST(Flags, stripEXTRA) { Flags mask = ModifierFlag::SHIFT_L | ModifierFlag::CONTROL_R | ModifierFlag::COMMAND_R; Flags flags = mask; EXPECT_EQ(mask, flags.stripEXTRA()); flags.add(ModifierFlag::EXTRA1); EXPECT_EQ(mask, flags.stripEXTRA()); flags.add(ModifierFlag::EXTRA2); EXPECT_EQ(mask, flags.stripEXTRA()); flags.add(ModifierFlag::EXTRA3 | ModifierFlag::EXTRA5); EXPECT_EQ(mask, flags.stripEXTRA()); }
void FlagStatus::updateStatusMessage(void) { #ifndef FLAGSTATUS_TEST Flags f = FlagStatus::getLockedFlags(); if (Config::get_essential_config(BRIDGE_ESSENTIAL_CONFIG_INDEX_general_show_sticky_modifier_status)) { f.add(FlagStatus::getStickyFlags()); } if (f != statusMessageFlags_) { int index = BRIDGE_USERCLIENT_STATUS_MESSAGE_MODIFIER; CommonData::clear_statusmessage(index); if (f.isOn(ModifierFlag::FN)) { CommonData::append_statusmessage(index, "FN "); } if (f.isOn(ModifierFlag::COMMAND_L) || f.isOn(ModifierFlag::COMMAND_R)) { CommonData::append_statusmessage(index, "Cmd "); } if (f.isOn(ModifierFlag::CONTROL_L) || f.isOn(ModifierFlag::CONTROL_R)) { CommonData::append_statusmessage(index, "Ctrl "); } if (f.isOn(ModifierFlag::OPTION_L) || f.isOn(ModifierFlag::OPTION_R)) { CommonData::append_statusmessage(index, "Opt "); } if (f.isOn(ModifierFlag::SHIFT_L) || f.isOn(ModifierFlag::SHIFT_R)) { CommonData::append_statusmessage(index, "Shift "); } if (f.isOn(ModifierFlag::EXTRA1)) { CommonData::append_statusmessage(index, "Ex1 "); } if (f.isOn(ModifierFlag::EXTRA2)) { CommonData::append_statusmessage(index, "Ex2 "); } if (f.isOn(ModifierFlag::EXTRA3)) { CommonData::append_statusmessage(index, "Ex3 "); } if (f.isOn(ModifierFlag::EXTRA4)) { CommonData::append_statusmessage(index, "Ex4 "); } if (f.isOn(ModifierFlag::EXTRA5)) { CommonData::append_statusmessage(index, "Ex5 "); } CommonData::send_notification_statusmessage(index); } statusMessageFlags_ = f; #endif }
TEST(Flags, stripFN) { Flags mask = ModifierFlag::SHIFT_L | ModifierFlag::CONTROL_R | ModifierFlag::COMMAND_R; Flags flags = mask; EXPECT_EQ(mask, flags.stripFN()); flags.add(ModifierFlag::FN); EXPECT_EQ(mask, flags.stripFN()); }
Flags FlagStatus::makeFlags(void) { Flags flags; for (int i = 0; item_[i].flag_ != ModifierFlag::NONE; ++i) { flags.add(item_[i].makeFlag()); } return flags; }
Flags FlagStatus::makeFlags(void) const { Flags flags; for (size_t i = 0; i < item_.size(); ++i) { if (item_[i].sum(false) > 0) { flags.add(item_[i].flag_); } } return flags; }
TEST(KeyCode, reverseNormalizeKey) { std::vector<NormalizeItem> vec; // ENTER_POWERBOOK vec.push_back(NormalizeItem(KeyCode::ENTER_POWERBOOK, ModifierFlag::SHIFT_L, KeyCode::ENTER_POWERBOOK, ModifierFlag::SHIFT_L, KeyboardType::POWERBOOK)); // ENTER_POWERBOOK(+FN) vec.push_back(NormalizeItem(KeyCode::ENTER_POWERBOOK, ModifierFlag::SHIFT_L | ModifierFlag::FN, KeyCode::ENTER_POWERBOOK, ModifierFlag::SHIFT_L | ModifierFlag::FN, KeyboardType::POWERBOOK)); // ---------------------------------------- // normal key (without FN) vec.push_back(NormalizeItem(KeyCode::A, ModifierFlag::SHIFT_L, KeyCode::A, ModifierFlag::SHIFT_L, KeyboardType::MACBOOK)); // KEYPAD (without FN) for (size_t i = 0; i < sizeof(keypads) / sizeof(keypads[0]); ++i) { KeyCode key = keypads[i][0]; Flags fromFlags = ModifierFlag::SHIFT_L; Flags toFlags = fromFlags; if (key != KeyCode::KEYPAD_CLEAR && key != KeyCode::KEYPAD_COMMA) toFlags.add(ModifierFlag::KEYPAD); vec.push_back(NormalizeItem(key, fromFlags, key, toFlags, KeyboardType::MACBOOK)); } // PAGEUP (without FN) for (size_t i = 0; i < sizeof(cursors) / sizeof(cursors[0]); ++i) { vec.push_back(NormalizeItem(cursors[i][0], ModifierFlag::SHIFT_L, cursors[i][0], ModifierFlag::SHIFT_L, KeyboardType::MACBOOK)); } // ENTER (without FN) vec.push_back(NormalizeItem(KeyCode::ENTER, ModifierFlag::SHIFT_L, KeyCode::ENTER, ModifierFlag::SHIFT_L, KeyboardType::MACBOOK)); // FORWARD_DELETE (without FN) vec.push_back(NormalizeItem(KeyCode::FORWARD_DELETE, ModifierFlag::SHIFT_L, KeyCode::FORWARD_DELETE, ModifierFlag::SHIFT_L, KeyboardType::MACBOOK)); // CURSOR (without FN) for (size_t i = 0; i < sizeof(cursors) / sizeof(cursors[0]); ++i) { vec.push_back(NormalizeItem(cursors[i][1], ModifierFlag::CURSOR, cursors[i][1], ModifierFlag::CURSOR, KeyboardType::MACBOOK)); } // ---------------------------------------- // normal key(+FN) vec.push_back(NormalizeItem(KeyCode::A, ModifierFlag::SHIFT_L | ModifierFlag::FN, KeyCode::A, ModifierFlag::SHIFT_L | ModifierFlag::FN, KeyboardType::MACBOOK)); // KEYPAD(+FN) for (size_t i = 0; i < sizeof(keypads) / sizeof(keypads[0]); ++i) { KeyCode key = keypads[i][0]; Flags fromFlags = ModifierFlag::SHIFT_L | ModifierFlag::FN; Flags toFlags = fromFlags; if (key != KeyCode::KEYPAD_CLEAR && key != KeyCode::KEYPAD_COMMA) toFlags.add(ModifierFlag::KEYPAD); vec.push_back(NormalizeItem(key, fromFlags, key, toFlags, KeyboardType::MACBOOK)); } // PAGEUP(+FN) for (size_t i = 0; i < sizeof(cursors) / sizeof(cursors[0]); ++i) { vec.push_back(NormalizeItem(cursors[i][0], ModifierFlag::SHIFT_L | ModifierFlag::FN, cursors[i][0], ModifierFlag::SHIFT_L | ModifierFlag::FN, KeyboardType::MACBOOK)); } // ENTER(+FN) vec.push_back(NormalizeItem(KeyCode::ENTER, ModifierFlag::SHIFT_L | ModifierFlag::FN, KeyCode::ENTER, ModifierFlag::SHIFT_L | ModifierFlag::FN, KeyboardType::MACBOOK)); // FORWARD_DELETE(+FN) vec.push_back(NormalizeItem(KeyCode::FORWARD_DELETE, ModifierFlag::SHIFT_L | ModifierFlag::FN, KeyCode::FORWARD_DELETE, ModifierFlag::SHIFT_L | ModifierFlag::FN, KeyboardType::MACBOOK)); // ---------------------------------------- for (std::vector<NormalizeItem>::iterator it = vec.begin(); it != vec.end(); ++it) { KeyCode key; // Down key = it->fromKeyCode; KeyCode::normalizeKey(key, it->fromFlags, EventType::DOWN, it->keyboardType); KeyCode::reverseNormalizeKey(key, it->fromFlags, EventType::DOWN, it->keyboardType); EXPECT_EQ(it->toKeyCode, key); EXPECT_EQ(it->fromFlags, it->toFlags); // Up key = it->fromKeyCode; KeyCode::normalizeKey(key, it->fromFlags, EventType::UP, it->keyboardType); KeyCode::reverseNormalizeKey(key, it->fromFlags, EventType::UP, it->keyboardType); EXPECT_EQ(it->toKeyCode, key); EXPECT_EQ(it->fromFlags, it->toFlags); } // ====================================================================== // Test case for the following key sequence. // (1) FN Down // (2) Right-Arrow Down // (3) FN Up // (4) Right-Arrow Up // KeyRemap4MacBook KeyboardEventCallback [ caught]: eventType 12, flags 0x800000, key 63, kbdType 37 // KeyRemap4MacBook KeyboardEventCallback [ caught]: eventType 10, flags 0x800000, key 119, kbdType 37 // KeyRemap4MacBook KeyboardEventCallback [ caught]: eventType 12, flags 0x0, key 63, kbdType 37 // KeyRemap4MacBook KeyboardEventCallback [ caught]: eventType 11, flags 0x0, key 119, kbdType 37 { KeyCode key = KeyCode::END; Flags flags = ModifierFlag::FN; KeyCode::normalizeKey(key, flags, EventType::DOWN, KeyboardType::MACBOOK); KeyCode::reverseNormalizeKey(key, flags, EventType::DOWN, KeyboardType::MACBOOK); EXPECT_EQ(key, KeyCode::END); EXPECT_EQ(flags, ModifierFlag::FN); key = KeyCode::END; flags = Flags(0); KeyCode::normalizeKey(key, flags, EventType::UP, KeyboardType::MACBOOK); KeyCode::reverseNormalizeKey(key, flags, EventType::UP, KeyboardType::MACBOOK); EXPECT_EQ(key, KeyCode::END); EXPECT_EQ(flags, 0); } // Test case for the following key sequence. // (1) Right-Arrow Down // (2) FN Down // (3) Right-Arrow UP // (4) FN Up // KeyRemap4MacBook KeyboardEventCallback [ caught]: eventType 10, flags 0x200000, key 124, kbdType 37 // KeyRemap4MacBook KeyboardEventCallback [ caught]: eventType 12, flags 0xa00000, key 63, kbdType 37 // KeyRemap4MacBook KeyboardEventCallback [ caught]: eventType 11, flags 0xa00000, key 124, kbdType 37 // KeyRemap4MacBook KeyboardEventCallback [ caught]: eventType 12, flags 0x0, key 63, kbdType 37 { KeyCode key = KeyCode::CURSOR_RIGHT; Flags flags = Flags(ModifierFlag::CURSOR); KeyCode::normalizeKey(key, flags, EventType::DOWN, KeyboardType::MACBOOK); KeyCode::reverseNormalizeKey(key, flags, EventType::DOWN, KeyboardType::MACBOOK); EXPECT_EQ(key, KeyCode::CURSOR_RIGHT); EXPECT_EQ(flags, ModifierFlag::CURSOR); key = KeyCode::CURSOR_RIGHT; flags = Flags(ModifierFlag::FN | ModifierFlag::CURSOR); KeyCode::normalizeKey(key, flags, EventType::UP, KeyboardType::MACBOOK); KeyCode::reverseNormalizeKey(key, flags, EventType::UP, KeyboardType::MACBOOK); EXPECT_EQ(key, KeyCode::CURSOR_RIGHT); EXPECT_EQ(flags, ModifierFlag::FN | ModifierFlag::CURSOR); } }