can I also switch layers while HRMs are held?

[bogorad]

I find Achordion immensely useful, loved it from the moment I tried it, many thanks to the author!

I use two different layouts, Colemak-DH for my base layer, and Qwerty for my Cyrillic layer (to ease the pain of mapping in windows on amd/arm). But while control/alt/meta (not shift obviously) are held, I want the mapping to switch to Colemak (since it's where my fingers expect the letters to be). I wrote some code using custom keycodes, variables, timers, etc, and it brings a lot of unnecessary complexity.

But then I thought - Achordion is already dealing with all that! Maybe there's a way to have a ride-along? Any ideas/suggestions are appreciated.

[NikGovorov]

Hey, I've got the same setup regarding the layers, however, I switch between the languages with a custom key code.
Here is the snippet from my process_record_user:

bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  if (record->event.pressed) {
    ...
    if (!process_achordion(keycode, record)) {
      return false;
    }
    ...
    switch (keycode) {
    ...
      case TG_LANG:
        if (record->event.pressed) {
          if (!IS_LAYER_ON(LR_RUS)) {
            tap_code16(LGUI(KC_SPACE));
            layer_on(LR_RUS);
          } else {
            tap_code16(LGUI(KC_SPACE));
            layer_off(LR_RUS);
          }
        }
      return false;
      ...
    }
    ...
  }
  ...
}

After TAPPING_TERM, HRMs should come to process_record_user as the regular events so it should be trivial to adjust the code to your needs.

[NikGovorov]

Ah I see, I don't think Achordion is relevant here though. The most direct approach I would employ involves simply handling RU_* key codes in QWERTY, and then generating the English Colemak-DH equivalents if a modifier key (or keys) is pressed. Here's an example of mapping LCTL+RU_KA to LCTL+KC_P. However, please be aware that I haven't actually tested this particular code, so take it with a grain of salt.

bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  if (record->event.pressed) {
    ...
    if (!process_achordion(keycode, record)) {
      return false;
    }
    ...
    switch (keycode) {
    ...
      case RU_KA:
        if (record->event.pressed) {
          if (IS_LAYER_ON(LR_RUS) && (QK_MOD_TAP_GET_MODS(keycode) & MOD_LCTL)) {
            tap_code16(LCTL(KC_P));
            return false;
          }
        }
        ...
    }
    ...
  }
  ...
}

[NikGovorov]

Just realised that I've never asked if you're using Russian key codes in QWERTY positions like I do or you're simply using English QWERTY and change the language only on OS level?

[LR_BASE] = LAYOUT(
        KC_Q,    KC_W,    KC_F,    KC_P,    KC_B,                               KC_J,    KC_L,    KC_U,    KC_Y,    KC_QUOTE,
        KC_A,    MTA_R,   MTS_S,   MTC_T,   KC_G,                               KC_M,    MTC_N,   MTS_E,   MTA_I,   KC_O,
        LT_MOD_Z,KC_X,    KC_C,    KC_D,    KC_V,                               KC_K,    KC_H,    KC_COMM, KC_DOT,  LT_MOD_SLSH,
    ),
[LR_RUS] = LAYOUT(
        RU_SHTI, RU_TSE,  RU_U,    RU_KA,   TH_RUIE,                            RU_EN,   RU_GHE,  TH_RUSHA,RU_HA,   RU_ZE,
        RU_EF,   RU_YERU, RU_VE,   RU_A,    RU_PE,                              RU_ER,   RU_O,    RU_EL,   RU_DE,   RU_ZHE,
        RU_YA,   RU_CHE,  RU_ES,   RU_EM,   RU_I,                               RU_TE,   TH_RUSFT,RU_BE,   RU_YU,   RU_E,
    )

In the second case you'll need to replace RU_KA with KC_R.

[bogorad]

The most direct approach I would employ involves simply handling RU_* key codes in QWERTY, and then generating the English Colemak-DH equivalents if a modifier key (or keys) is pressed.

I think that's inelegant. Here's what I did for my symbols/numpad layer. LT_SYM_ENT sends enter on tap, temp.switches to English and activates U_SYM while held. LT_NUM_BSPC, likewise.

I could do more or less the same for HRMs, but I'll need to keep all relevant "pressed" statuses etc, wanted a cleaner way.

////////////////////////////////////////////////
// Define a structure to hold layer-tap information
typedef struct {
    bool     is_active;
    bool     command_sent;
    uint16_t timer;
} layer_tap_t;

  // Initialize structure instance for holding state
layer_tap_t my_lt = {false, false, 0};

//////////////// here we switch languages
//
// define fallback first
void switch_to_english(void) {
  // Save mods.
  uint8_t mod_state = get_mods();
  // Clear mods so Windows doesn't get confused.
  clear_mods();
  // Ctrl+Alt+0 sent to host
  SEND_STRING(SS_LSFT(SS_LALT("0")));
  // Switch to default layer.
  layer_move(U_BASE);
  // debug
  dprint("Switched to English!\n");
  // Restore mods.
  set_mods(mod_state);
};

#define RUS_LAYER_TIMEOUT 5000  // timeout in milliseconds

void switch_to_russian(void) {
  // switch back to English if already in Russian mode
  if (get_highest_layer(layer_state) == U_EXTRA) {
    dprint("Russian active! Switching back to English\n");
    switch_to_english();
  }
  else
  {
    // Save mods.
    uint8_t mod_state = get_mods();
    // Clear mods so Windows doesn't get confused.
    clear_mods();
    // Ctrl+Alt+1 sent to host
    SEND_STRING(SS_LSFT(SS_LALT("1")));
    // Switch to Cyrillic-friendly layer.
    layer_move(U_EXTRA);
    // debug
    dprint("Switched to Russian!\n");
    // Restore mods.
    set_mods(mod_state);
  };
};

/////////////////////////////////////////////////
void matrix_scan_user(void) {
  // achordion
  achordion_task();
  //
  // this resets current language to English after <timeout> if Russian was active
  if (get_highest_layer(layer_state) == U_EXTRA) {
    if (last_input_activity_elapsed() > RUS_LAYER_TIMEOUT) {
      switch_to_english();
    }
  }
}

////////////////////////////////////////////////////////////////////
// This switches to English but only when LT-key is pressed and another key it tapped.
//
// Function to handle layer-tap logic
void process_layer_tap(uint16_t keycode, uint16_t layer, keyrecord_t *record) {
    if (record->event.pressed) {
        // Key was pressed - start timer.
        my_lt.timer = timer_read();
        my_lt.is_active = true;
        layer_on(layer);
        dprintf("lt: pressed!\n");
    } else { // Key was released
        // Was it a tap?
        if (my_lt.is_active && timer_elapsed(my_lt.timer) < TAPPING_TERM) {
            tap_code(keycode);
            dprintf("lt: tapped!\n");
        }
        layer_off(layer);
        // Only retore win kbd layout if it was switched.
        if (my_lt.command_sent) {
          // Tell Windows we're still in Cyrillic
          SEND_STRING(SS_LSFT(SS_LALT("1")));
          // Clear flag.
          my_lt.command_sent = false;
          dprintf("lt: sent SA(1) to windows!\n");
        }
        my_lt.is_active = false;
        dprintf("lt: released!\n");
    }
}

/////////////////////////////////////////////////
// macro processor etc
bool process_record_user(uint16_t keycode, keyrecord_t *record) {
  uint8_t mod_state = get_mods();
  //
  // only print to HID console when debugging is on
  dprintf("KL: kc: 0x%04X, col: %3u, row: %3u, pressed: %u, time: %5u, int: %u, count: %u layer: %u\n",
          keycode,
          record->event.key.col,
          record->event.key.row,
          record->event.pressed,
          record->event.time,
          record->tap.interrupted,
          record->tap.count,
          get_highest_layer(layer_state));
  //
  // achordion
  if (!process_achordion(keycode, record)) { return false; }
  //
  // check for specific keycodes
  switch (keycode) {
    //
    // fake keys first
    case LANG_ENG:
      if (record->event.pressed)
        switch_to_english();
      return false; // Skip further processing
        //
    case LANG_RUS:
      if (record->event.pressed)
        switch_to_russian();
      return false; // Skip further processing
        //
/////////////////////////////////////
        // special consideration for TAB & ESCAPE & digits
    case LT(U_MOUSE,KC_TAB):
    case LT(U_MEDIA,KC_ESC):
      // only operate if pressed
      if (record->event.pressed &&
          // Ignore if held
          record->tap.count     &&
          // Check if the current layer is U_EXTRA
          layer_state_cmp(layer_state, U_EXTRA) &&
          // And any of the modifiers are active
          (mod_state & (MOD_BIT(KC_LALT) |
                        MOD_BIT(KC_LSFT) |
                        MOD_BIT(KC_LCTL) |
                        MOD_BIT(KC_LGUI)
                       )))
      {
        switch_to_english();
      };
      return true; // Continue normal tab processing
      //
/////////////////////////////////////////
    case LT_SYM_ENT:
      process_layer_tap(KC_ENT, U_SYM, record);
      return false; // Skip all further processing of this key
      //
    case LT_NUM_BSPC:
      process_layer_tap(KC_BSPC, U_NUM, record);
      return false; // Skip all further processing of this key
      //
    default:
      if (my_lt.is_active && record->event.pressed) {
        // Only switch win kbd layout if it has not been switched.
        if (!my_lt.command_sent) {
          // Custom function called when any key is pressed while MY_LT is active
          my_lt.command_sent = true;
          SEND_STRING(SS_LSFT(SS_LALT("0")));
          dprintf("lt: sent SA(0) to windows!\n");
        }
        return true;  // Allow the key press to be handled normally by QMK
      }
      break;
  } // done with specific keys
  //
  return true;
}

[bogorad]

I also considered sending all RU characters as UNICODE, but under windows it's a pain.

[bogorad]

https://bogorad.medium.com/qmk-and-cyrillic-2323f1a61fa0

[bogorad]

For now, I settled on this quick hack.

https://github.com/bogorad/home-automation/blob/main/manna-harbour_miryoku.c