ਲੀਨਕਸ ਲਈ Xswitcher ਲੇਆਉਟ ਸੁਧਾਰਕ: ਕਦਮ ਦੋ

ਲੈ ਪਿਛਲੇ ਪ੍ਰਕਾਸ਼ਨ ("ਸੰਕਲਪ ਦਾ ਸਬੂਤ" ਪੜਾਅ 'ਤੇ xswitcher) ਨੂੰ ਕਾਫ਼ੀ ਰਚਨਾਤਮਕ ਫੀਡਬੈਕ ਪ੍ਰਾਪਤ ਹੋਇਆ ਹੈ (ਜੋ ਵਧੀਆ ਹੈ), ਮੈਂ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਵਿਕਸਿਤ ਕਰਨ ਲਈ ਆਪਣਾ ਖਾਲੀ ਸਮਾਂ ਬਿਤਾਉਣਾ ਜਾਰੀ ਰੱਖਿਆ। ਹੁਣ ਮੈਂ ਤੁਹਾਡਾ ਥੋੜਾ ਜਿਹਾ ਖਰਚ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ ... ਦੂਜਾ ਕਦਮ ਬਹੁਤ ਆਮ ਨਹੀਂ ਹੋਵੇਗਾ: ਸੰਰਚਨਾ ਡਿਜ਼ਾਈਨ ਦਾ ਪ੍ਰਸਤਾਵ/ਚਰਚਾ।

ਕਿਸੇ ਤਰ੍ਹਾਂ ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਆਮ ਪ੍ਰੋਗਰਾਮਰਾਂ ਨੂੰ ਇਹ ਸਾਰੇ ਨਿਯੰਤਰਣ ਸਥਾਪਤ ਕਰਨ ਲਈ ਬਹੁਤ ਬੋਰਿੰਗ ਲੱਗਦੀ ਹੈ.

ਬੇਬੁਨਿਆਦ ਨਾ ਹੋਣ ਲਈ, ਅੰਦਰ ਇੱਕ ਉਦਾਹਰਣ ਹੈ ਜਿਸ ਨਾਲ ਮੈਂ ਨਜਿੱਠ ਰਿਹਾ ਹਾਂ.
ਕੁੱਲ ਮਿਲਾ ਕੇ ਸ਼ਾਨਦਾਰ ਢੰਗ ਨਾਲ ਕਲਪਨਾ ਕੀਤੀ ਗਈ (ਅਤੇ ਚੰਗੀ ਤਰ੍ਹਾਂ ਲਾਗੂ ਕੀਤੀ ਗਈ) ਅਪਾਚੇ ਕਾਫਕਾ ਅਤੇ ਜ਼ੂਕੀਪਰ।
- ਸੰਰਚਨਾ? ਪਰ ਇਹ ਬੋਰਿੰਗ ਹੈ! ਡੰਬ xml (ਕਿਉਂਕਿ ਇਹ "ਬਾਕਸ ਤੋਂ ਬਾਹਰ" ਹੈ)।
- ਓ, ਕੀ ਤੁਸੀਂ ਵੀ ਏਸੀਐਲ ਚਾਹੁੰਦੇ ਹੋ? ਪਰ ਇਹ ਬਹੁਤ ਬੋਰਿੰਗ ਹੈ! ਟੈਪ-ਬਲੂਪਰ... ਅਜਿਹਾ ਕੁਝ।

ਪਰ ਮੇਰੇ ਕੰਮ ਵਿੱਚ ਇਹ ਬਿਲਕੁਲ ਉਲਟ ਹੈ। ਸੱਜਾ (ਹਾਏ, ਲਗਭਗ ਪਹਿਲੀ ਵਾਰ ਕਦੇ ਨਹੀਂ) ਨਿਰਮਿਤ ਮਾਡਲ ਤੁਹਾਨੂੰ ਹੋਰ ਆਸਾਨੀ ਨਾਲ ਅਤੇ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਜਾਰੀ ਰੱਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ (ਲਗਭਗ) ਇੱਕ ਚਿੱਤਰ ਨੂੰ ਇਕੱਠਾ ਕਰੋ.

ਮੈਂ ਹਾਲ ਹੀ ਵਿੱਚ ਡੇਟਾ ਵਿਗਿਆਨੀਆਂ ਦੀ ਸਖ਼ਤ ਮਿਹਨਤ ਬਾਰੇ ਹੈਬਰੇ ਉੱਤੇ ਇੱਕ ਲੇਖ ਵਿੱਚ ਆਇਆ ...
ਇਹ ਪਤਾ ਚਲਦਾ ਹੈ ਕਿ ਇਹ ਪਲ ਉਹਨਾਂ ਲਈ ਪੂਰੀ ਤਰ੍ਹਾਂ ਅਨੁਭਵ ਕੀਤਾ ਗਿਆ ਹੈ. ਅਤੇ ਮੇਰੇ ਅਭਿਆਸ ਵਿੱਚ, ਜਿਵੇਂ ਕਿ ਉਹ ਕਹਿੰਦੇ ਹਨ, "ਹਲਕਾ ਸੰਸਕਰਣ". ਮਲਟੀ-ਵੋਲਿਊਮ ਮਾਡਲ, ਤਿਆਰ 'ਤੇ ਓਓਪੀ ਵਾਲੇ ਤਜਰਬੇਕਾਰ ਪ੍ਰੋਗਰਾਮਰ, ਆਦਿ। - ਇਹ ਸਭ ਬਾਅਦ ਵਿੱਚ ਦਿਖਾਈ ਦੇਵੇਗਾ ਜਦੋਂ/ਜੇ ਇਹ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ। ਪਰ ਡਿਜ਼ਾਈਨਰ ਨੂੰ ਇੱਥੇ ਅਤੇ ਹੁਣ ਕਿਤੇ ਸ਼ੁਰੂ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ.

ਬਿੰਦੂ 'ਤੇ ਪ੍ਰਾਪਤ ਕਰੋ. ਮੈਂ TOML ਨੂੰ ਇੱਕ ਸਿੰਟੈਕਟਿਕ ਅਧਾਰ ਵਜੋਂ ਲਿਆ ਇਸ ਨਾਗਰਿਕ ਤੋਂ.

ਕਿਉਂਕਿ ਉਹ (TOML) ਇੱਕ ਪਾਸੇ, ਮਨੁੱਖੀ-ਸੰਪਾਦਨਯੋਗ। ਦੂਜੇ ਪਾਸੇ, ਇਸਦਾ ਅਨੁਵਾਦ 1:1 ਨੂੰ ਕਿਸੇ ਵੀ ਵਧੇਰੇ ਆਮ ਸੰਟੈਕਸ ਵਿੱਚ ਕੀਤਾ ਗਿਆ ਹੈ: XML, JSON, YAML।
ਇਸ ਤੋਂ ਇਲਾਵਾ, ਮੈਂ "github.com/BurntSushi/toml" ਤੋਂ ਵਰਤਿਆ ਗਿਆ ਅਮਲ, ਹਾਲਾਂਕਿ ਸਭ ਤੋਂ ਵੱਧ ਫੈਸ਼ਨੇਬਲ (ਅਜੇ ਵੀ 1.4 ਸੰਟੈਕਸ) ਨਹੀਂ ਹੈ, ਉਸੇ ("ਬਿਲਟ-ਇਨ") JSON ਨਾਲ ਸਿੰਟੈਕਟਿਕ ਤੌਰ 'ਤੇ ਅਨੁਕੂਲ ਹੈ।

ਭਾਵ, ਜੇਕਰ ਤੁਸੀਂ ਚਾਹੋ, ਤਾਂ ਤੁਸੀਂ ਬਸ ਕਹਿ ਸਕਦੇ ਹੋ "ਤੁਹਾਡੇ ਦੇ ਉਸ TOML ਨਾਲ ਜੰਗਲ ਵਿੱਚੋਂ ਲੰਘੋ, ਮੈਨੂੰ XXX ਚਾਹੀਦਾ ਹੈ" ਅਤੇ ਕੋਡ ਨੂੰ ਸਿਰਫ਼ ਇੱਕ ਲਾਈਨ ਨਾਲ "ਪੈਚ" ਕਰੋ।

ਇਸ ਤਰ੍ਹਾਂ, ਜੇ ਤੁਸੀਂ xswitcher ਨੂੰ ਸੰਰਚਿਤ ਕਰਨ ਲਈ ਕੁਝ ਵਿੰਡੋਜ਼ ਲਿਖਣਾ ਚਾਹੁੰਦੇ ਹੋ (ਮੈਂ ਪੱਕਾ ਨਹੀਂ ਕਹਿ ਸਕਦਾ) "ਤੁਹਾਡੀ ਇਸ ਲਾਹਨਤ ਸੰਰਚਨਾ ਨਾਲ" ਕਿਸੇ ਸਮੱਸਿਆ ਦੀ ਉਮੀਦ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ।

ਬਾਕੀ ਸਭ ਲਈ, ਸੰਟੈਕਸ "ਕੁੰਜੀ = ਮੁੱਲ" 'ਤੇ ਅਧਾਰਤ ਹੈ (ਅਤੇ ਸ਼ਾਬਦਿਕ ਤੌਰ 'ਤੇ ਕੁਝ ਹੋਰ ਗੁੰਝਲਦਾਰ ਵਿਕਲਪ, ਜਿਵੇਂ ਕਿ = [ਕੁਝ, ਉਹ, ਐਰੇ]) ਸ਼ਾਇਦ
ਅਨੁਭਵੀ ਤੌਰ 'ਤੇ ਸੁਵਿਧਾਜਨਕ।
ਦਿਲਚਸਪ ਗੱਲ ਇਹ ਹੈ ਕਿ "ਸੜਿਆ" ਉਸੇ ਸਮੇਂ (2013 ਦੇ ਆਸ-ਪਾਸ)। ਕੇਵਲ, ਮੇਰੇ ਤੋਂ ਉਲਟ, TOML ਦਾ ਲੇਖਕ ਸਹੀ ਪੈਮਾਨੇ 'ਤੇ ਗਿਆ.

ਇਸ ਲਈ, ਹੁਣ ਮੇਰੇ ਲਈ ਇਸ ਦੇ ਲਾਗੂਕਰਨ ਨੂੰ ਆਪਣੇ ਅਨੁਕੂਲ ਬਣਾਉਣਾ ਸੌਖਾ ਹੈ, ਨਾ ਕਿ ਉਲਟ।

ਆਮ ਤੌਰ 'ਤੇ, ਅਸੀਂ TOML (ਪੁਰਾਣੇ ਵਿੰਡੋਜ਼ INI ਦੇ ਸਮਾਨ) ਲੈਂਦੇ ਹਾਂ। ਅਤੇ ਸਾਡੇ ਕੋਲ ਇੱਕ ਸੰਰਚਨਾ ਹੈ ਜਿਸ ਵਿੱਚ ਅਸੀਂ ਵਰਣਨ ਕਰਦੇ ਹਾਂ ਕਿ ਕੀਬੋਰਡ ਤੋਂ ਨਵੀਨਤਮ ਸਕੈਨ ਕੋਡਾਂ ਦੇ ਸੈੱਟ ਦੇ ਅਧਾਰ ਤੇ ਹੁੱਕਾਂ ਦੀ ਇੱਕ ਲੜੀ ਨੂੰ ਕਿਵੇਂ ਜੋੜਨਾ ਹੈ। ਹੇਠਾਂ, ਟੁਕੜੇ-ਟੁਕੜੇ, ਹੁਣ ਤੱਕ ਕੀ ਹੋਇਆ ਹੈ। ਅਤੇ ਇਸ ਗੱਲ ਦੀ ਵਿਆਖਿਆ ਕਿ ਮੈਂ ਇਸ ਤਰ੍ਹਾਂ ਦਾ ਫੈਸਲਾ ਕਿਉਂ ਕੀਤਾ।

0 ਬੁਨਿਆਦੀ ਐਬਸਟਰੈਕਸ਼ਨ

• ਕੋਡ ਅਹੁਦਿਆਂ ਨੂੰ ਸਕੈਨ ਕਰੋ। ਇਸ ਬਾਰੇ ਨਿਸ਼ਚਤ ਤੌਰ 'ਤੇ ਕੁਝ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੈ, ਕਿਉਂਕਿ ਸਿਰਫ਼ ਡਿਜੀਟਲ ਕੋਡ ਮਨੁੱਖੀ-ਪੜ੍ਹਨ ਯੋਗ ਨਹੀਂ ਹਨ (ਇਹ ਸਿਰਫ਼ ਮੈਂ ਹਾਂ loloswitcher).
  ਮੈਂ "ਗੋਲਾਂਗ-ਏਵਦੇਵ" ਤੋਂ "ecodes.go" ਨੂੰ ਹਿਲਾ ਦਿੱਤਾ (ਮੈਂ ਅਸਲ ਸਰੋਤ ਨੂੰ ਦੇਖਣ ਲਈ ਬਹੁਤ ਆਲਸੀ ਸੀ, ਹਾਲਾਂਕਿ ਲੇਖਕ ਨੇ ਇਸਨੂੰ ਕਾਫ਼ੀ ਸੱਭਿਆਚਾਰਕ ਤੌਰ 'ਤੇ ਦਰਸਾਇਆ ਹੈ)। ਮੈਂ ਥੋੜਾ ਜਿਹਾ (ਹੁਣ ਲਈ) ਕੁਝ ਠੀਕ ਕੀਤਾ ਜੋ ਕਾਫ਼ੀ ਡਰਾਉਣਾ ਸੀ। ਜਿਵੇਂ ਕਿ “LEFTBRACE” → “L_BRACE”।
• ਇਸ ਤੋਂ ਇਲਾਵਾ, ਉਸਨੇ "ਸਟੇਟ ਕੁੰਜੀਆਂ" ਦੀ ਧਾਰਨਾ ਪੇਸ਼ ਕੀਤੀ। ਕਿਉਂਕਿ ਵਰਤਿਆ ਜਾਣ ਵਾਲਾ ਨਿਯਮਤ ਵਿਆਕਰਣ ਲੰਬੇ ਅੰਸ਼ਾਂ ਦੀ ਆਗਿਆ ਨਹੀਂ ਦਿੰਦਾ ਹੈ। (ਪਰ ਇਹ ਤੁਹਾਨੂੰ ਘੱਟੋ-ਘੱਟ ਓਵਰਹੈੱਡ ਨਾਲ ਜਾਂਚ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ਼ "ਸਿੱਧੀ" ਰਿਕਾਰਡਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ।)
• ਜੋ ਦਬਾਇਆ ਜਾਂਦਾ ਹੈ ਉਸ ਦਾ ਇੱਕ ਬਿਲਟ-ਇਨ "ਡਿਡਪਲੀਕੇਟਰ" ਹੋਵੇਗਾ। ਇਸ ਤਰ੍ਹਾਂ, ਅਵਸਥਾ "ਦੁਹਰਾਓ" = 2 ਲਿਖਿਆ ਜਾਵੇਗਾ один ਵਾਰ

1. ਟੈਂਪਲੇਟ ਸੈਕਸ਼ਨ

[Templates] # "@name@" to simplify expressions
 # Words can consist of these chars (regex)
 "WORD" = "([0-9A-Z`;']|[LR]_BRACE|COMMA|DOT|SLASH|KP[0-9])"

ਧੁਨੀਆਤਮਕ ਸੰਕੇਤ ਦੇ ਨਾਲ ਇੱਕ ਮਨੁੱਖੀ ਭਾਸ਼ਾ ਦੇ ਸ਼ਬਦ ਵਿੱਚ ਕੀ ਹੁੰਦਾ ਹੈ? (ਜਾਂ ਤਾਂ ਗ੍ਰਾਫੀਮ ਉਰਫ "ਹਾਇਰੋਗਲਿਫਸ" ਦਾ ਮਾਮਲਾ)? ਕੁਝ ਕਿਸਮ ਦੀ ਭਿਆਨਕ "ਸ਼ੀਟ"। ਇਸ ਲਈ, ਮੈਂ ਤੁਰੰਤ "ਟੈਂਪਲੇਟ" ਦੀ ਧਾਰਨਾ ਪੇਸ਼ ਕਰਦਾ ਹਾਂ.

2. ਜਦੋਂ ਕੁਝ ਕਲਿੱਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਤਾਂ ਕੀ ਕਰਨਾ ਹੈ (ਇੱਕ ਹੋਰ ਸਕੈਨ ਕੋਡ ਆ ਗਿਆ ਹੈ)

[ActionKeys]
 # Collect key and do the test for command sequence
 # !!! Repeat codes (code=2) must be collected once per key!
 Add = ["1..0", "=", "BS", "Q..]", "L_CTRL..CAPS", "N_LOCK", "S_LOCK",
        "KP7..KPDOT", "R_CTRL", "KPSLASH", "R_ALT", "KPEQUAL..PAUSE",
        "KPCOMMA", "L_META..COMPOSE", "KPLEFTPAREN", "KPRIGHTPAREN"]

 # Drop all collected keys, including this.  This is default action.
 Drop = ["ESC", "-", "TAB", "ENTER", "KPENTER", "LINEFEED..POWER"]
 # Store extra map for these keys, when any is in "down" state.
 # State is checked via "OFF:"|"ON:" conditions in action.
 # (Also, state of these keys must persist between buffer drops.)
 # ??? How to deal with CAPS and "LOCK"-keys ???
 StateKeys = ["L_CTRL", "L_SHIFT", "L_ALT", "L_META", "CAPS", "N_LOCK", "S_LOCK",
              "R_CTRL", "R_SHIFT", "R_ALT", "R_META"]

 # Test only, but don't collect.
 # E.g., I use F12 instead of BREAK on dumb laptops whith shitty keyboards (new ThinkPads)
 Test = ["F1..F10", "ZENKAKUHANKAKU", "102ND", "F11", "F12",
          "RO..KPJPCOMMA", "SYSRQ", "SCALE", "HANGEUL..YEN",
          "STOP..SCROLLDOWN", "NEW..MAX"]

ਕੁੱਲ 768 ਕੋਡ ਹਨ। (ਪਰ “ਸਿਰਫ਼ ਮਾਮਲੇ ਵਿੱਚ” ਮੈਂ xswitcher ਕੋਡ ਵਿੱਚ “ਸਰਪ੍ਰਾਈਜ਼” ਨੂੰ ਫੜਨਾ ਸ਼ਾਮਲ ਕੀਤਾ)।
ਅੰਦਰ ਮੈਂ "ਕੀ ਕਰਨਾ ਹੈ" ਫੰਕਸ਼ਨਾਂ ਦੇ ਲਿੰਕਾਂ ਨਾਲ ਐਰੇ ਨੂੰ ਭਰਨ ਦਾ ਵਰਣਨ ਕੀਤਾ ਹੈ। ਗੋਲੰਗ ਵਿੱਚ ਇਹ ਹੈ (ਅਚਾਨਕ) ਇਹ ਸੁਵਿਧਾਜਨਕ ਅਤੇ ਸਪੱਸ਼ਟ ਹੋ ਗਿਆ.

• ਮੈਂ ਇਸ ਥਾਂ 'ਤੇ "ਡ੍ਰੌਪ" ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਕਰਨ ਦੀ ਯੋਜਨਾ ਬਣਾ ਰਿਹਾ ਹਾਂ। ਵਧੇਰੇ ਲਚਕਦਾਰ ਪ੍ਰੋਸੈਸਿੰਗ ਦੇ ਹੱਕ ਵਿੱਚ (ਮੈਂ ਇਸਨੂੰ ਹੇਠਾਂ ਦਿਖਾਵਾਂਗਾ).

3. ਵਿੰਡੋ ਕਲਾਸਾਂ ਵਾਲਾ ਟੇਬਲ

# Some behaviour can depend on application currently doing the input.
[[WindowClasses]]
 # VNC, VirtualBox, qemu etc. emulates there input independently, so never intercept.
 # With the exception of some stupid VNC clients, which does high-level (layout-based) keyboard input.
 Regex = "^VirtualBox"
 Actions = "" # Do nothing while focus stays in VirtualBox

[[WindowClasses]]
 Regex = "^konsole"
 # In general, mouse clicks leads to unpredictable (at the low-level where xswitcher resides) cursor jumps.
 # So, it's good choise to drop all buffers after click.
 # But some windows, e.g. terminals, can stay out of this problem.
 MouseClickDrops = 0
 Actions = "Actions"

[[WindowClasses]] # Default behaviour: no Regex (or wildcard like ".")
 MouseClickDrops = 1
 Actions = "Actions"

ਸਾਰਣੀ ਦੀਆਂ ਕਤਾਰਾਂ ਇਸਦੇ ਨਾਮ ਦੇ ਨਾਲ ਦੋਹਰੇ ਵਰਗ ਬਰੈਕਟਾਂ ਵਿੱਚ ਹਨ। ਇਹ ਬੱਲੇਬਾਜ਼ੀ ਤੋਂ ਆਸਾਨ ਨਹੀਂ ਹੋ ਸਕਦਾ ਸੀ। ਮੌਜੂਦਾ ਕਿਰਿਆਸ਼ੀਲ ਵਿੰਡੋ 'ਤੇ ਨਿਰਭਰ ਕਰਦਿਆਂ, ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਵਿਕਲਪਾਂ ਦੀ ਚੋਣ ਕਰ ਸਕਦੇ ਹੋ:

• "ਹੌਟ ਕੁੰਜੀਆਂ" "ਐਕਸ਼ਨ = …" ਦਾ ਤੁਹਾਡਾ ਆਪਣਾ ਸੈੱਟ। ਜੇ ਨਹੀਂ/ਖਾਲੀ ਹੈ, ਤਾਂ ਕੁਝ ਨਾ ਕਰੋ।
• "MouseClickDrops" ਨੂੰ ਬਦਲੋ - ਜਦੋਂ ਮਾਊਸ ਕਲਿੱਕ ਦਾ ਪਤਾ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ ਤਾਂ ਕੀ ਕਰਨਾ ਹੈ। ਕਿਉਂਕਿ ਉਸ ਬਿੰਦੂ 'ਤੇ ਜਿੱਥੇ xswitcher ਚਾਲੂ ਹੁੰਦਾ ਹੈ, "ਉਹ ਕਿੱਥੇ ਕਲਿਕ ਕਰਦੇ ਹਨ" ਬਾਰੇ ਕੋਈ ਵੇਰਵੇ ਨਹੀਂ ਹੁੰਦੇ ਹਨ, ਅਸੀਂ ਮੂਲ ਰੂਪ ਵਿੱਚ ਬਫਰ ਨੂੰ ਰੀਸੈਟ ਕਰਦੇ ਹਾਂ। ਪਰ ਟਰਮੀਨਲਾਂ ਵਿੱਚ (ਉਦਾਹਰਨ ਲਈ) ਤੁਹਾਨੂੰ ਅਜਿਹਾ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ (ਆਮ ਤੌਰ 'ਤੇ).

4. ਕਲਿੱਕਾਂ ਦੇ ਇੱਕ (ਜਾਂ ਕਈ) ਕ੍ਰਮ ਇੱਕ ਜਾਂ ਦੂਜੇ ਹੁੱਕ ਨੂੰ ਟਰਿੱਗਰ ਕਰਦੇ ਹਨ

# action = [ regex1, regex2, ... ]
# "CLEAN" state: all keys are released
[Actions]
# Inverse regex is hard to understand, so extract negation to external condition.
# Expresions will be checked in direct order, one-by-one. Condition succceds when ALL results are True.
 # Maximum key sequence length, extra keys will be dropped. More length - more CPU.
 SeqLength = 8
 # Drop word buffer and start collecting new one
 NewWord = [ "OFF:(CTRL|ALT|META)  SEQ:(((BACK)?SPACE|[LR]_SHIFT):[01],)*(@WORD@:1)", # "@WORD@:0" then collects the char
             "SEQ:(@WORD@:2,@WORD@:0)", # Drop repeated char at all: unlikely it needs correction
             "SEQ:((KP)?MINUS|(KP)?ENTER|ESC|TAB)" ] # Be more flexible: chars line "-" can start new word, but must not completelly invalidate buffer!
 # Drop all buffers
 NewSentence = [ "SEQ:(ENTER:0)" ]

 # Single char must be deleted by single BS, so there is need in compose sequence detector.
 Compose = [ "OFF:(CTRL|L_ALT|META|SHIFT)  SEQ:(R_ALT:1,(R_ALT:2,)?(,@WORD@:1,@WORD@:0){2},R_ALT:0)" ]

 "Action.RetypeWord" = [ "OFF:(CTRL|ALT|META|SHIFT)  SEQ:(PAUSE:0)" ]
 "Action.CyclicSwitch" = [ "OFF:(R_CTRL|ALT|META|SHIFT)  SEQ:(L_CTRL:1,L_CTRL:0)" ] # Single short LEFT CONTROL
 "Action.Respawn" = [ "OFF:(CTRL|ALT|META|SHIFT)  SEQ:(S_LOCK:2,S_LOCK:0)" ] # Long-pressed SCROLL LOCK

 "Action.Layout0" = [ "OFF:(CTRL|ALT|META|R_SHIFT)  SEQ:(L_SHIFT:1,L_SHIFT:0)" ] # Single short LEFT SHIFT
 "Action.Layout1" = [ "OFF:(CTRL|ALT|META|L_SHIFT)  SEQ:(R_SHIFT:1,R_SHIFT:0)" ] # Single short RIGHT SHIFT

 "Action.Hook1" = [ "OFF:(CTRL|R_ALT|META|SHIFT)  SEQ:(L_ALT:1,L_ALT:0)" ]

ਹੁੱਕਾਂ ਨੂੰ ਦੋ ਕਿਸਮਾਂ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ। ਬਿਲਟ-ਇਨ, "ਬੋਲਣ" ਨਾਮਾਂ (ਨਿਊਵਰਡ, ਨਿਊਸੇਂਟੈਂਸ, ਕੰਪੋਜ਼) ਅਤੇ ਪ੍ਰੋਗਰਾਮੇਬਲ ਦੇ ਨਾਲ।

ਪ੍ਰੋਗਰਾਮੇਬਲ ਨਾਮ "ਐਕਸ਼ਨ" ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ। ਕਿਉਂਕਿ TOML v1.4, ਬਿੰਦੀਆਂ ਵਾਲੇ ਨਾਮ ਕੋਟਸ ਵਿੱਚ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ।

ਹਰੇਕ ਭਾਗ ਨੂੰ ਹੇਠਾਂ ਵਰਣਨ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਉਸੇ ਨਾਮ ਨਾਲ.

ਲੋਕਾਂ ਦੇ ਮਨਾਂ ਨੂੰ "ਨੰਗੇ" ਨਿਯਮਤ (ਤਜ਼ਰਬੇ ਤੋਂ, ਉਹਨਾਂ ਦੇ ਲਿਖਣ ਲਈਸ਼ਾਇਦ ਦਸ ਵਿੱਚੋਂ ਇੱਕ ਪੇਸ਼ੇਵਰ), ਮੈਂ ਤੁਰੰਤ ਵਾਧੂ ਸੰਟੈਕਸ ਲਾਗੂ ਕਰਦਾ ਹਾਂ।

• "ਬੰਦ:" (ਜਾਂ "ਚਾਲੂ:") regexp (ਰੈਗੂਲਰ ਸਮੀਕਰਨ) ਤੋਂ ਪਹਿਲਾਂ ਹੇਠਾਂ ਦਿੱਤੇ ਬਟਨਾਂ ਨੂੰ ਜਾਰੀ ਕਰਨ (ਜਾਂ ਦਬਾਏ ਜਾਣ) ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
  ਅੱਗੇ ਮੈਂ ਇੱਕ "ਅਣਉਚਿਤ" ਨਿਯਮਤ ਸਮੀਕਰਨ ਬਣਾਉਣ ਜਾ ਰਿਹਾ ਹਾਂ। ਪਾਈਪਾਂ ਵਿਚਕਾਰ ਟੁਕੜਿਆਂ ਦੀ ਵੱਖਰੀ ਜਾਂਚ ਦੇ ਨਾਲ "|"। ਰਿਕਾਰਡਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਜਿਵੇਂ ਕਿ "[LR]_SHIFT" (ਜਿੱਥੇ ਇਹ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ)।
• "SEQ:" ਜੇ ਪਿਛਲੀ ਸ਼ਰਤ ਪੂਰੀ ਹੁੰਦੀ ਹੈ (ਜਾਂ ਗੈਰਹਾਜ਼ਰ), ਤਾਂ ਅਸੀਂ "ਆਮ" ਨਿਯਮਤ ਸਮੀਕਰਨ ਦੇ ਵਿਰੁੱਧ ਜਾਂਚ ਕਰਦੇ ਹਾਂ। ਵੇਰਵਿਆਂ ਲਈ, ਮੈਂ ਤੁਰੰਤ ^W “regexp” ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਭੇਜਦਾ ਹਾਂ। ਕਿਉਂਕਿ ਮੈਂ ਅਜੇ ਵੀ ਆਪਣੇ ਮਨਪਸੰਦ pcre ("ਪਰਲ ਅਨੁਕੂਲ") ਨਾਲ ਅਨੁਕੂਲਤਾ ਦੀ ਡਿਗਰੀ ਦਾ ਪਤਾ ਲਗਾਉਣ ਦੀ ਖੇਚਲ ਨਹੀਂ ਕੀਤੀ ਹੈ।
• ਸਮੀਕਰਨ ਰੂਪ ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ "BUTTON_1: CODE1, BUTTON_2: CODE2" ਆਦਿ, ਜਿਸ ਕ੍ਰਮ ਵਿੱਚ ਸਕੈਨ ਕੋਡ ਪ੍ਰਾਪਤ ਹੁੰਦੇ ਹਨ।
• ਕ੍ਰਮ ਦੇ ਅੰਤ ਤੱਕ ਚੈਕ ਹਮੇਸ਼ਾ "ਸੰਨਗਡ" ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਪੂਛ ਵਿੱਚ "$" ਜੋੜਨ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ।
• ਇੱਕ ਲਾਈਨ ਵਿੱਚ ਸਾਰੀਆਂ ਜਾਂਚਾਂ ਇੱਕ ਤੋਂ ਬਾਅਦ ਇੱਕ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ "I" ਦੁਆਰਾ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ। ਪਰ ਕਿਉਂਕਿ ਮੁੱਲ ਨੂੰ ਇੱਕ ਐਰੇ ਵਜੋਂ ਦਰਸਾਇਆ ਗਿਆ ਹੈ, ਤੁਸੀਂ ਕਾਮੇ ਤੋਂ ਬਾਅਦ ਇੱਕ ਵਿਕਲਪਿਕ ਜਾਂਚ ਲਿਖ ਸਕਦੇ ਹੋ। ਜੇਕਰ ਕਿਸੇ ਕਾਰਨ ਕਰਕੇ ਇਸਦੀ ਲੋੜ ਹੈ।
• ਮੁੱਲ "SeqLength = 8" ਬਫਰ ਦੇ ਆਕਾਰ ਨੂੰ ਸੀਮਿਤ ਕਰਦਾ ਹੈ ਜਿਸ ਦੇ ਵਿਰੁੱਧ ਸਾਰੀਆਂ ਜਾਂਚਾਂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਕਿਉਂਕਿ ਮੈਂ (ਹੁਣ ਤੱਕ) ਕਦੇ ਵੀ ਆਪਣੇ ਜੀਵਨ ਵਿੱਚ ਬੇਅੰਤ ਸਰੋਤਾਂ ਦਾ ਸਾਹਮਣਾ ਨਹੀਂ ਕੀਤਾ।

5. ਪਿਛਲੇ ਭਾਗ ਵਿੱਚ ਦੱਸੇ ਗਏ ਹੁੱਕਾਂ ਨੂੰ ਸੈੱਟ ਕਰਨਾ

# Action is the array, so actions could be chained (m.b., infinitely... Have I to check this?).
# For each action type, extra named parameters could be collected. Invalid parameters will be ignored(?).
[Action.RetypeWord] # Switch layout, drop last word and type it again
 Action = [ "Action.CyclicSwitch", "RetypeWord" ] # Call Switch() between layouts tuned below, then RetypeWord()

[Action.CyclicSwitch] # Cyclic layout switching
 Action = [ "Switch" ] # Internal layout switcher func
 Layouts = [0, 1]

[Action.Layout0] # Direct layout selection
 Action = [ "Layout" ] # Internal layout selection func
 Layout = 0

[Action.Layout1] # Direct layout selection
 Action = [ "Layout" ] # Internal layout selection func
 Layout = 1

[Action.Respawn] # Completely respawn xswitcher. Reload config as well
 Action = [ "Respawn" ]

[Action.Hook1] # Run external commands
  Action = [ "Exec" ]
  Exec = "/path/to/exec -a -b --key_x"
  Wait = 1
  SendBuffer = "Word" # External hook can process collected buffer by it's own means.

ਇੱਥੇ ਮੁੱਖ ਗੱਲ ਇਹ ਹੈ "ਐਕਸ਼ਨ = [ਐਰੇ]". ਪਿਛਲੇ ਭਾਗ ਦੇ ਸਮਾਨ, ਬਿਲਟ-ਇਨ ਕਾਰਵਾਈਆਂ ਦਾ ਇੱਕ ਸੀਮਤ ਸਮੂਹ ਹੈ। ਅਤੇ ਡੌਕਿੰਗ ਦੀ ਸੰਭਾਵਨਾ ਸਿਧਾਂਤ ਵਿੱਚ ਸੀਮਿਤ ਨਹੀਂ ਹੈ (“ਐਕਸ਼ਨ.XXX” ਲਿਖੋ ਅਤੇ ਇਸਦੇ ਲਈ ਕੋਈ ਹੋਰ ਸੈਕਸ਼ਨ ਲਿਖਣ ਲਈ ਬਹੁਤ ਆਲਸੀ ਨਾ ਬਣੋ).
ਖਾਸ ਤੌਰ 'ਤੇ, ਸਹੀ ਕੀਤੇ ਖਾਕੇ ਵਿੱਚ ਇੱਕ ਸ਼ਬਦ ਦੀ ਦੁਬਾਰਾ ਟਾਈਪਿੰਗ ਨੂੰ ਦੋ ਹਿੱਸਿਆਂ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ: "ਉੱਥੇ ਦੱਸੇ ਅਨੁਸਾਰ ਖਾਕਾ ਬਦਲੋ" и "ਰੀਟਾਈਪ" ("ਰੀਟਾਈਪਵਰਡ").

ਬਾਕੀ ਪੈਰਾਮੀਟਰ "ਡਕਸ਼ਨਰੀ" ਵਿੱਚ ਲਿਖੇ ਗਏ ਹਨ (ਗੋਲਾਂਗ ਵਿੱਚ "ਨਕਸ਼ੇ") ਦਿੱਤੀ ਗਈ ਕਾਰਵਾਈ ਲਈ, ਉਹਨਾਂ ਦੀ ਸੂਚੀ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਕਿ "ਐਕਸ਼ਨ" ਵਿੱਚ ਕੀ ਲਿਖਿਆ ਗਿਆ ਹੈ।

ਇੱਕ ਹੀਪ ਵਿੱਚ ਕਈ ਵੱਖ-ਵੱਖ ਕਿਰਿਆਵਾਂ ਦਾ ਵਰਣਨ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ (ਭਾਗ). ਜਾਂ ਤੁਸੀਂ ਇਸਨੂੰ ਵੱਖ ਕਰ ਸਕਦੇ ਹੋ। ਜਿਵੇਂ ਕਿ ਮੈਂ ਉੱਪਰ ਦਿਖਾਇਆ ਹੈ.

ਮੈਂ ਤੁਰੰਤ ਬਾਹਰੀ ਸਕ੍ਰਿਪਟ ਨੂੰ ਚਲਾਉਣ ਲਈ "Exec" ਐਕਸ਼ਨ ਸੈੱਟ ਕੀਤਾ। ਰਿਕਾਰਡ ਕੀਤੇ ਬਫਰ ਨੂੰ stdin ਵਿੱਚ ਧੱਕਣ ਦੇ ਵਿਕਲਪ ਦੇ ਨਾਲ।

• "ਉਡੀਕ = 1" - ਚੱਲ ਰਹੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਪੂਰਾ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰੋ।
• ਸ਼ਾਇਦ, "ਢੇਰ ਤੱਕ" ਤੁਸੀਂ ਵਾਤਾਵਰਣ ਵਿੱਚ ਵਾਧੂ ਲੋਕਾਂ ਨੂੰ ਰੱਖਣਾ ਚਾਹੋਗੇ। ਜਾਣਕਾਰੀ ਜਿਵੇਂ ਕਿ ਵਿੰਡੋ ਕਲਾਸ ਦਾ ਨਾਮ ਜਿੱਥੋਂ ਇਸਨੂੰ ਰੋਕਿਆ ਗਿਆ ਸੀ।
  "ਕੀ ਤੁਸੀਂ ਆਪਣੇ ਹੈਂਡਲਰ ਨੂੰ ਜੋੜਨਾ ਚਾਹੁੰਦੇ ਹੋ? ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਤੁਹਾਨੂੰ ਜਾਣ ਦੀ ਲੋੜ ਹੈ। ”

ਫੇਉ (ਸਾਹ ਛੱਡਿਆ)। ਅਜਿਹਾ ਲਗਦਾ ਹੈ ਕਿ ਮੈਂ ਕੁਝ ਵੀ ਨਹੀਂ ਭੁੱਲਿਆ.

ਓਹ! ਹਾਂ, ਮੈਂ ਨਹੀਂ ਭੁੱਲਿਆ ...
ਲਾਂਚ ਕੌਂਫਿਗਰੇਸ਼ਨ ਕਿੱਥੇ ਹੈ? ਹਾਰਡ ਕੋਡ ਵਿੱਚ? ਓਸ ਵਾਂਗ:

[ScanDevices]
 # Must exist on start. Self-respawn in case it is younger then 30s
 Test = "/dev/input/event0"
 Respawn = 30
 # Search mask
 Search = "/dev/input/event*"
 # In my thinkPads there are such a pseudo-keyboards whith tons of unnecessary events
 Bypass = "(?i)Video|Camera" # "(?i)" obviously differs from "classic" pcre's.

ਮੈਂ ਕਿੱਥੇ ਭੁੱਲ ਗਿਆ/ਗਲਤੀ ਕੀਤੀ? (ਇਸ ਤੋਂ ਬਿਨਾਂ ਕੋਈ ਰਸਤਾ ਨਹੀਂ), ਮੈਂ ਸੱਚਮੁੱਚ ਆਸ ਕਰਦਾ ਹਾਂ ਕਿ ਸੁਚੇਤ ਪਾਠਕ ਆਪਣਾ ਨੱਕ ਦਬਾਉਣ ਲਈ ਬਹੁਤ ਆਲਸੀ ਨਹੀਂ ਹੋਣਗੇ.

ਚੰਗੀ ਕਿਸਮਤ!

ਸਰੋਤ: www.habr.com