Added @forward-modifiers directive

README.md

@@ -338,6 +338,22 @@ Meta{C} >> $(start powershell) ^
 
 The following directives, which are lines starting with an `@`, can be inserted in the configuration file:
 
+- `forward-modifiers` allows to set a list of keys which should never be [held back](#order-of-mappings). e.g.:
+ ```python
+ @forward-modifiers Shift Control AltLeft
+ ```
+ It effectively forwards these keys in each [stage](#multiple-stages) immediately, like:
+ ```bash
+ Shift >> Shift
+ Control >> Control
+ AltLeft >> AltLeft
+ ```
+ and automatically suppresses the forwarded keys in the output:
+ ```bash
+ # implicitly turned into 'Control{A} >> !Control Shift{B}'
+ Control{A} >> Shift{B}
+ ```
+
 - `allow-unmapped-commands` and `enforce-lowercase-commands` change the way [commands](#abstract-commands) are validated. When used, then best together, so typing errors in key names are still detected. e.g.:
  ```python
  @allow-unmapped-commands

src/config/Config.h

@@ -16,7 +16,6 @@ struct Config {
  };
 
  struct Context {
- bool system_filter_matched{ };
  Filter window_class_filter;
  Filter window_title_filter;
  Filter window_path_filter;
@@ -26,6 +25,7 @@ struct Config {
  std::vector<Input> inputs;
  std::vector<KeySequence> outputs;
  std::vector<CommandOutput> command_outputs;
+ bool system_filter_matched{ };
  bool invert_modifier_filter{ };
  bool fallthrough{ };
  bool begin_stage{ };

src/config/ParseConfig.cpp

@@ -57,6 +57,11 @@ namespace {
  }) != cend(sequence);
  }
 
+ bool contains(const KeySequence& sequence, KeyEvent event) {
+ return std::find(cbegin(sequence), 
+ cend(sequence), event) != cend(sequence);
+ }
+
  void replace_key(KeySequence& sequence, Key both, Key key) {
  std::for_each(begin(sequence), end(sequence),
  [&](KeyEvent& event) {
@@ -178,9 +183,12 @@ Config ParseConfig::operator()(std::istream& is,
  m_after_empty_context_block = false;
  m_enforce_lowercase_commands = { };
  m_allow_unmapped_commands = { };
+ m_forward_modifiers.clear();
 
  // add default context
- m_config.contexts.push_back({ true, {}, {} });
+ auto& default_context = m_config.contexts.emplace_back();
+ default_context.begin_stage = true;
+ default_context.system_filter_matched = true;
 
  // register common logical keys
  add_logical_key("Shift", Key::ShiftLeft, Key::ShiftRight);
@@ -195,6 +203,9 @@ Config ParseConfig::operator()(std::istream& is,
  if (!command.mapped)
  throw ConfigError("Command '" + command.name + "' was not mapped");
 
+ // prepend forward-modifier mappings in each stage. e.g.: ShiftLeft >> ShiftLeft
+ prepend_forward_modifier_mappings();
+
  // remove contexts of other systems or which are empty
  optimize_contexts();
 
@@ -204,6 +215,8 @@ Config ParseConfig::operator()(std::istream& is,
  replace_logical_key(both, left, right);
  }
 
+ suppress_forwarded_modifiers_in_outputs();
+
  // collect virtual key aliases
  for (const auto& [name, value] : m_macros)
  if (auto key = get_key_by_name(value); is_virtual_key(key))
@@ -391,6 +404,9 @@ void ParseConfig::parse_directive(It it, const It end) {
  else if (ident == "allow-unmapped-commands") {
  m_allow_unmapped_commands = read_optional_bool();
  }
+ else if (ident == "forward-modifiers") {
+ m_forward_modifiers = parse_forward_modifiers_list(&it, end);
+ }
  else {
  error("Unknown directive '" + ident + "'");
  }
@@ -453,6 +469,30 @@ KeySequence ParseConfig::parse_modifier_list(std::string_view string) {
  return sequence;
 }
 
+std::vector<Key> ParseConfig::parse_forward_modifiers_list(It* it, const It end) {
+ auto modifiers = std::vector<Key>();
+ while (*it != end) {
+ const auto name = read_ident(it, end);
+ if (name.empty())
+ error("Key name expected");
+
+ const auto it2 = std::find_if(m_logical_keys.begin(), m_logical_keys.end(),
+ [&](const LogicalKey& key) { return key.name == name; });
+ if (it2 != m_logical_keys.end()) {
+ modifiers.push_back(it2->left);
+ modifiers.push_back(it2->right);
+ }
+ else if (const auto key = ::get_key_by_name(name); is_device_key(key)) {
+ modifiers.push_back(key);
+ }
+ else {
+ error("Invalid key '" + name + "'");
+ }
+ skip_space(it, end);
+ }
+ return modifiers;
+}
+
 void ParseConfig::parse_context(It it, const It end) {
  auto& context = m_config.contexts.emplace_back();
  context.system_filter_matched = true;
@@ -931,7 +971,7 @@ void ParseConfig::optimize_contexts() {
  const auto has_no_effect = (
  context.inputs.empty() && 
  context.command_outputs.empty() &&
- !context.begin_stage);
+ (i == 0 || !context.begin_stage));
 
  if (can_not_match || has_no_effect) {
  // convert fallthrough context when removing the non-fallthrough context
@@ -953,3 +993,53 @@ void ParseConfig::optimize_contexts() {
  }
  }
 }
+
+void ParseConfig::prepend_forward_modifier_mappings() {
+ for (auto& context : m_config.contexts)
+ if (context.begin_stage)
+ for (auto it = m_forward_modifiers.rbegin(); 
+ it != m_forward_modifiers.rend(); ++it) {
+ const auto key = *it;
+ context.inputs.insert(context.inputs.begin(), {
+ KeySequence{ 
+ KeyEvent(key, KeyState::Down),
+ KeyEvent(key, KeyState::UpAsync)
+ },
+ static_cast<int>(context.outputs.size())
+ });
+ context.outputs.push_back({
+ KeyEvent(key, KeyState::Down)
+ });
+ }
+}
+
+void ParseConfig::suppress_forwarded_modifiers_in_outputs() {
+ if (m_forward_modifiers.empty())
+ return;
+
+ for (auto& context : m_config.contexts) {
+ for (auto key : m_forward_modifiers) {
+ const auto down_event = KeyEvent(key, KeyState::Down);
+ const auto not_event = KeyEvent(key, KeyState::Not);
+ const auto prepend_not_event = [&](KeySequence& output) {
+ if (!contains(output, down_event) &&
+ !contains(output, not_event))
+ output.insert(output.begin(), not_event);
+ };
+
+ for (auto& input : context.inputs)
+ if (contains(input.input, down_event)) {
+ if (input.output_index >= 0) {
+ prepend_not_event(context.outputs[input.output_index]);
+ }
+ else {
+ for (auto& following_context : m_config.contexts) {
+ for (auto& command : following_context.command_outputs)
+ if (command.index == input.output_index)
+ prepend_not_event(command.output);
+ }
+ }
+ }
+ }
+ }
+}

src/config/ParseConfig.h

@@ -47,6 +47,7 @@ class ParseConfig {
  It out_begin, It out_end);
  KeySequence parse_input(It begin, It end);
  KeySequence parse_output(It begin, It end);
+ std::vector<Key> parse_forward_modifiers_list(It* it, It end);
  std::string substitute_variables(std::string string) const;
  std::string preprocess(It begin, It end, bool apply_arguments = true) const;
  std::string preprocess(std::string expression) const;
@@ -59,6 +60,8 @@ class ParseConfig {
  Key get_key_by_name(std::string_view name) const;
  Key add_terminal_command_action(std::string_view command);
  void optimize_contexts();
+ void prepend_forward_modifier_mappings();
+ void suppress_forwarded_modifiers_in_outputs();
 
  Config::Context& current_context();
  Command* find_command(const std::string& name);
@@ -80,4 +83,5 @@ class ParseConfig {
  bool m_after_empty_context_block{ };
  bool m_enforce_lowercase_commands{ };
  bool m_allow_unmapped_commands{ };
+ std::vector<Key> m_forward_modifiers;
 };

src/test/test1_ParseConfig.cpp

@@ -326,6 +326,84 @@ TEST_CASE("Config directives", "[ParseConfig]") {
 
 //--------------------------------------------------------------------
 
+TEST_CASE("Forward modifiers directive", "[ParseConfig]") {
+ CHECK_NOTHROW(parse_config(R"(
+ @forward-modifiers
+ @forward-modifiers A ; comment
+ @forward-modifiers Shift Control # comment
+ )"));
+ CHECK_THROWS(parse_config(R"(@forward-modifiers Shft)"));
+ CHECK_THROWS(parse_config(R"(@forward-modifiers Shift ^)"));
+ CHECK_THROWS(parse_config(R"(@forward-modifiers 100ms)"));
+ CHECK_THROWS(parse_config(R"(@forward-modifiers Any)"));
+ CHECK_THROWS(parse_config(R"(@forward-modifiers ContextActive)"));
+
+ auto config = parse_config(R"(
+ @forward-modifiers Shift Control AltLeft
+ Control{A} >> Shift{X}
+ Control{B} >> command
+ ControlLeft{C} >> command
+ AltLeft{D} >> command
+ command >> Shift{Y}
+
+ [title="app"]
+ command >> Control{Z}
+
+ [stage]
+ ShiftRight{X} >> Z
+ )");
+ REQUIRE(config.contexts.size() == 3);
+ const auto& c0 = config.contexts[0];
+ const auto& c1 = config.contexts[1];
+ const auto& c2 = config.contexts[2];
+ REQUIRE(c0.inputs.size() == 11);
+ REQUIRE(c0.outputs.size() == 6);
+ REQUIRE(c0.command_outputs.size() == 1);
+ // inputs are inserted at the front
+ CHECK(format_sequence(c0.inputs[0].input) == "+ShiftLeft ~ShiftLeft");
+ CHECK(format_sequence(c0.inputs[1].input) == "+ShiftRight ~ShiftRight");
+ CHECK(format_sequence(c0.inputs[2].input) == "+ControlLeft ~ControlLeft");
+ CHECK(format_sequence(c0.inputs[3].input) == "+ControlRight ~ControlRight");
+ CHECK(format_sequence(c0.inputs[4].input) == "+AltLeft ~AltLeft");
+ CHECK(format_sequence(c0.inputs[5].input) == "+ControlLeft +A ~A ~ControlLeft");
+ CHECK(format_sequence(c0.inputs[6].input) == "+ControlRight +A ~A ~ControlRight");
+ CHECK(format_sequence(c0.inputs[7].input) == "+ControlLeft +B ~B ~ControlLeft");
+ CHECK(format_sequence(c0.inputs[8].input) == "+ControlRight +B ~B ~ControlRight");
+ CHECK(format_sequence(c0.inputs[9].input) == "+ControlLeft +C ~C ~ControlLeft");
+ CHECK(format_sequence(c0.inputs[10].input) == "+AltLeft +D ~D ~AltLeft");
+ // forwarded modifiers in input are suppressed in output
+ CHECK(format_sequence(c0.command_outputs[0].output) == 
+ "!AltLeft !ControlRight !ControlLeft +ShiftLeft +Y -Y -ShiftLeft");
+ CHECK(format_sequence(c0.outputs[0]) == 
+ "!ControlRight !ControlLeft +ShiftLeft +X -X -ShiftLeft");
+ // outputs are prepended (in reverse order)
+ CHECK(format_sequence(c0.outputs[1]) == "+AltLeft");
+ CHECK(format_sequence(c0.outputs[2]) == "+ControlRight");
+ CHECK(format_sequence(c0.outputs[3]) == "+ControlLeft");
+ CHECK(format_sequence(c0.outputs[4]) == "+ShiftRight");
+ CHECK(format_sequence(c0.outputs[5]) == "+ShiftLeft");
+
+ REQUIRE(c1.inputs.size() == 0);
+ REQUIRE(c1.outputs.size() == 0);
+ REQUIRE(c1.command_outputs.size() == 1);
+ CHECK(format_sequence(c1.command_outputs[0].output) == 
+ "!AltLeft !ControlRight +ControlLeft +Z -Z -ControlLeft");
+
+ // modifiers are forwarded in each stage
+ REQUIRE(c2.inputs.size() == 6);
+ REQUIRE(c2.outputs.size() == 6);
+ REQUIRE(c2.command_outputs.empty());
+ CHECK(format_sequence(c2.inputs[0].input) == "+ShiftLeft ~ShiftLeft");
+ CHECK(format_sequence(c2.inputs[1].input) == "+ShiftRight ~ShiftRight");
+ CHECK(format_sequence(c2.inputs[2].input) == "+ControlLeft ~ControlLeft");
+ CHECK(format_sequence(c2.inputs[3].input) == "+ControlRight ~ControlRight");
+ CHECK(format_sequence(c2.inputs[4].input) == "+AltLeft ~AltLeft");
+ CHECK(format_sequence(c2.inputs[5].input) == "+ShiftRight +X ~X ~ShiftRight");
+ CHECK(format_sequence(c2.outputs[0]) == "!ShiftRight +Z");
+}
+
+//--------------------------------------------------------------------
+
 TEST_CASE("System contexts", "[ParseConfig]") {
  auto string = R"(
  [default]
@@ -609,7 +687,7 @@ TEST_CASE("Stages", "[ParseConfig]") {
 
  auto config = parse_config(string);
  REQUIRE(config.contexts.size() == 9);
- CHECK(!config.contexts[0].begin_stage);
+ CHECK(config.contexts[0].begin_stage);
  CHECK(config.contexts[1].begin_stage);
  CHECK(!config.contexts[2].begin_stage);
  CHECK(config.contexts[3].begin_stage);