ರಿಂದ ("ಪರಿಕಲ್ಪನೆಯ ಪುರಾವೆ" ಹಂತದಲ್ಲಿ xswitcher) ಸಾಕಷ್ಟು ರಚನಾತ್ಮಕ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಪಡೆಯಿತು (ಇದು ಚೆನ್ನಾಗಿದೆ), ನಾನು ಯೋಜನೆಯನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲು ನನ್ನ ಬಿಡುವಿನ ಸಮಯವನ್ನು ಕಳೆಯುವುದನ್ನು ಮುಂದುವರೆಸಿದೆ. ಈಗ ನಾನು ನಿಮ್ಮ ಸ್ವಲ್ಪ ಖರ್ಚು ಮಾಡಲು ಬಯಸುತ್ತೇನೆ ... ಎರಡನೇ ಹಂತವು ತುಂಬಾ ಸಾಮಾನ್ಯವಾಗಿರುವುದಿಲ್ಲ: ಸಂರಚನಾ ವಿನ್ಯಾಸದ ಪ್ರಸ್ತಾವನೆ/ಚರ್ಚೆ.
ಹೇಗಾದರೂ ಇದು ಸಾಮಾನ್ಯ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಈ ಎಲ್ಲಾ ನಿಯಂತ್ರಣಗಳನ್ನು ಹೊಂದಿಸಲು ನಂಬಲಾಗದಷ್ಟು ನೀರಸ ಎಂದು ತಿರುಗುತ್ತದೆ.
ಆಧಾರರಹಿತವಾಗಿರದಿರಲು, ಒಳಗೆ ನಾನು ವ್ಯವಹರಿಸುತ್ತಿದ್ದೇನೆ ಎಂಬುದಕ್ಕೆ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ.
ಒಟ್ಟಾರೆಯಾಗಿ ಅತ್ಯುತ್ತಮವಾಗಿ ಕಲ್ಪಿಸಲಾಗಿದೆ (ಮತ್ತು ಉತ್ತಮವಾಗಿ ಅಳವಡಿಸಲಾಗಿದೆ) ಅಪಾಚೆ ಕಾಫ್ಕಾ ಮತ್ತು ಝೂಕೀಪರ್.
- ಕಾನ್ಫಿಗರೇಶನ್? ಆದರೆ ಇದು ಬೇಸರವಾಗಿದೆ! ಮೂಕ xml (ಏಕೆಂದರೆ ಅದು "ಬಾಕ್ಸ್‌ನಿಂದ ಹೊರಗಿದೆ").
- ಓಹ್, ನಿಮಗೂ ACL ಬೇಕೇ? ಆದರೆ ಇದು ತುಂಬಾ ಬೇಸರವಾಗಿದೆ! ಟ್ಯಾಪ್-ಬ್ಲೂಪರ್... ಅಂತಹದ್ದೇನೋ.
ಆದರೆ ನನ್ನ ಕೆಲಸದಲ್ಲಿ ಇದು ನಿಖರವಾಗಿ ವಿರುದ್ಧವಾಗಿದೆ. ಸರಿ (ಅಯ್ಯೋ, ಮೊದಲ ಬಾರಿಗೆ ಎಂದಿಗೂ) ನಿರ್ಮಿಸಿದ ಮಾದರಿಯು ನಿಮಗೆ ಸುಲಭವಾಗಿ ಮತ್ತು ನೈಸರ್ಗಿಕವಾಗಿ ಮುಂದುವರಿಯಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ (ಬಹುತೇಕ) ರೇಖಾಚಿತ್ರವನ್ನು ಜೋಡಿಸಿ.
ದತ್ತಾಂಶ ವಿಜ್ಞಾನಿಗಳ ಕಠಿಣ ಪರಿಶ್ರಮದ ಕುರಿತು ನಾನು ಇತ್ತೀಚೆಗೆ ಹಬ್ರೆ ಲೇಖನವನ್ನು ನೋಡಿದೆ ...
ಈ ಕ್ಷಣವು ಅವರಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಅರಿತುಕೊಂಡಿದೆ ಎಂದು ಅದು ತಿರುಗುತ್ತದೆ. ಮತ್ತು ನನ್ನ ಅಭ್ಯಾಸದಲ್ಲಿ, ಅವರು ಹೇಳಿದಂತೆ, "ಬೆಳಕಿನ ಆವೃತ್ತಿ". ಮಲ್ಟಿ-ವಾಲ್ಯೂಮ್ ಮಾಡೆಲ್‌ಗಳು, ಸಿದ್ಧವಾಗಿರುವ OOP ಜೊತೆಗೆ ಕಾಲಮಾನದ ಪ್ರೋಗ್ರಾಮರ್ಗಳು, ಇತ್ಯಾದಿ. — ಇದು ಟೇಕ್ ಆಫ್ ಆಗಿದ್ದರೆ/ಇದೆಲ್ಲವೂ ನಂತರ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ. ಆದರೆ ಡಿಸೈನರ್ ಇಲ್ಲಿ ಮತ್ತು ಈಗ ಎಲ್ಲೋ ಪ್ರಾರಂಭಿಸಬೇಕಾಗಿದೆ.
ವಿಷಯಕ್ಕೆ ಬನ್ನಿ. ನಾನು TOML ಅನ್ನು ವಾಕ್ಯರಚನೆಯ ಆಧಾರವಾಗಿ ತೆಗೆದುಕೊಂಡೆ .
ಏಕೆಂದರೆ ಅವನು (TOML) ಒಂದೆಡೆ, ಮಾನವ ಸಂಪಾದಿಸಬಹುದಾದ. ಮತ್ತೊಂದೆಡೆ, ಇದು 1:1 ಅನ್ನು ಯಾವುದೇ ಸಾಮಾನ್ಯ ಸಿಂಟ್ಯಾಕ್ಸ್‌ಗಳಿಗೆ ಅನುವಾದಿಸಲಾಗಿದೆ: XML, JSON, YAML.
ಇದಲ್ಲದೆ, "github.com/BurntSushi/toml" ನಿಂದ ನಾನು ಬಳಸಿರುವ ಅನುಷ್ಠಾನವು ಅತ್ಯಂತ ಸೊಗಸುಗಾರ ಅಲ್ಲದಿದ್ದರೂ (ಇನ್ನೂ 1.4 ಸಿಂಟ್ಯಾಕ್ಸ್), ಅದೇ ("ಅಂತರ್ನಿರ್ಮಿತ") JSON ನೊಂದಿಗೆ ವಾಕ್ಯರಚನೆಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.
ಅಂದರೆ, ನೀವು ಬಯಸಿದರೆ, "ನಿಮ್ಮ TOML ನೊಂದಿಗೆ ಕಾಡಿನ ಮೂಲಕ ಹೋಗಿ, ನನಗೆ XXX ಬೇಕು" ಮತ್ತು ಕೇವಲ ಒಂದು ಸಾಲಿನೊಂದಿಗೆ ಕೋಡ್ ಅನ್ನು "ಪ್ಯಾಚ್" ಎಂದು ಸರಳವಾಗಿ ಹೇಳಬಹುದು.
ಹೀಗಾಗಿ, ನೀವು xswitcher ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಕೆಲವು ವಿಂಡೋಗಳನ್ನು ಬರೆಯಲು ಬಯಸಿದರೆ (ನನಗೆ ಖಚಿತವಿಲ್ಲ) "ನಿಮ್ಮ ಈ ಡ್ಯಾಮ್ ಸಂರಚನೆಯೊಂದಿಗೆ" ಯಾವುದೇ ಸಮಸ್ಯೆಗಳನ್ನು ನಿರೀಕ್ಷಿಸಲಾಗುವುದಿಲ್ಲ.
ಎಲ್ಲಾ ಇತರರಿಗೆ, ಸಿಂಟ್ಯಾಕ್ಸ್ "ಕೀ = ಮೌಲ್ಯ" ಅನ್ನು ಆಧರಿಸಿದೆ (ಮತ್ತು ಅಕ್ಷರಶಃ ಒಂದೆರಡು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಆಯ್ಕೆಗಳು, ಹಾಗೆ = [ಕೆಲವು, ಅದು, ರಚನೆ]) ನಾನು ಊಹಿಸುತ್ತೇನೆ
ಅಂತರ್ಬೋಧೆಯಿಂದ ಅನುಕೂಲಕರ.
ಆಸಕ್ತಿದಾಯಕ ಸಂಗತಿಯೆಂದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ (ಸುಮಾರು 2013). ಕೇವಲ, ನನ್ನಂತಲ್ಲದೆ, TOML ನ ಲೇಖಕರು ಸರಿಯಾದ ಪ್ರಮಾಣದಲ್ಲಿ ಹೋದರು.
ಆದ್ದರಿಂದ, ಈಗ ನನಗೆ ಸರಿಹೊಂದುವಂತೆ ಅದರ ಅನುಷ್ಠಾನವನ್ನು ಸರಿಹೊಂದಿಸಲು ನನಗೆ ಸುಲಭವಾಗಿದೆ ಮತ್ತು ಪ್ರತಿಯಾಗಿ ಅಲ್ಲ.
ಸಾಮಾನ್ಯವಾಗಿ, ನಾವು TOML ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ (ಹಳೆಯ ವಿಂಡೋಸ್ INI ಗೆ ಹೋಲುತ್ತದೆ). ಮತ್ತು ಕೀಬೋರ್ಡ್‌ನಿಂದ ಇತ್ತೀಚಿನ ಸ್ಕ್ಯಾನ್ ಕೋಡ್‌ಗಳ ಸೆಟ್ ಅನ್ನು ಅವಲಂಬಿಸಿ ಕೊಕ್ಕೆಗಳ ಸರಣಿಯನ್ನು ಹೇಗೆ ಲಗತ್ತಿಸುವುದು ಎಂಬುದನ್ನು ನಾವು ವಿವರಿಸುವ ಸಂರಚನೆಯನ್ನು ನಾವು ಹೊಂದಿದ್ದೇವೆ. ಕೆಳಗೆ, ತುಂಡು ತುಂಡು, ಇಲ್ಲಿಯವರೆಗೆ ಏನಾಯಿತು. ಮತ್ತು ನಾನು ಈ ರೀತಿ ಏಕೆ ನಿರ್ಧರಿಸಿದೆ ಎಂಬುದರ ವಿವರಣೆ.
0. ಮೂಲ ಅಮೂರ್ತತೆಗಳು
- ಕೋಡ್ ಪದನಾಮಗಳನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡಿ. ಈ ಬಗ್ಗೆ ಖಂಡಿತವಾಗಿಯೂ ಏನಾದರೂ ಮಾಡಬೇಕಾಗಿದೆ, ಏಕೆಂದರೆ ಸರಳವಾಗಿ ಡಿಜಿಟಲ್ ಕೋಡ್‌ಗಳು ಸಂಪೂರ್ಣವಾಗಿ ಮಾನವ-ಓದಲು ಸಾಧ್ಯವಿಲ್ಲ (ಅದು ನಾನು ಮಾತ್ರ ).
ನಾನು "golang-evdev" ನಿಂದ "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 ("perl compatible") ನೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯ ಮಟ್ಟವನ್ನು ಕಂಡುಹಿಡಿಯಲು ನಾನು ಇನ್ನೂ ತಲೆಕೆಡಿಸಿಕೊಂಡಿಲ್ಲ.
- ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ರೂಪದಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ "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.
ಇಲ್ಲಿ ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ "ಕ್ರಿಯೆ = [ಅರೇ]". ಹಿಂದಿನ ವಿಭಾಗದಂತೆಯೇ, ಅಂತರ್ನಿರ್ಮಿತ ಕ್ರಿಯೆಗಳ ಸೀಮಿತ ಸೆಟ್ ಇದೆ. ಮತ್ತು ಡಾಕಿಂಗ್ ಸಾಧ್ಯತೆಯು ತಾತ್ವಿಕವಾಗಿ ಸೀಮಿತವಾಗಿಲ್ಲ ("Action.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