सभी अनुप्रयोगों को मेरे संशोधित xkb लेआउट का सम्मान कैसे करें?

मुझे मुख्य कीबोर्ड और आंदोलन कुंजियों के बीच कूदना पसंद नहीं है, इसलिए मैंने अपनी xkb लेआउट फ़ाइल में निम्नलिखित को जोड़ा।

hidden partial xkb_symbols "movement"
{
    key <AD08> { [ NoSymbol, NoSymbol, Up,          Up          ] };
    key <AC08> { [ NoSymbol, NoSymbol, Down,        Down        ] };
    key <AC07> { [ NoSymbol, NoSymbol, Left,        Left        ] };
    key <AC09> { [ NoSymbol, NoSymbol, Right,       Right       ] };
    key <AD09> { [ NoSymbol, NoSymbol, Prior,       Prior       ] };
    key <AB09> { [ NoSymbol, NoSymbol, Next,        Next        ] };
    key <AB07> { [ NoSymbol, NoSymbol, Home,        Home        ] };
    key <AB08> { [ NoSymbol, NoSymbol, End,         End         ] };
    key <AC06> { [ NoSymbol, NoSymbol, Delete,      Delete      ] };
}

फिर मैं उन्हें फ़ाइल में बाद के बिंदु पर लेआउट में शामिल करता हूं। अब मेरे पास AltGr + j, k, l, i (or h, t, n, c, जैसे कि मैं dvorak का उपयोग कर रहा हूं) के माध्यम से पहुंच योग्य कर्सर कुंजी होनी चाहिए। यह कई मामलों में काम करता है (जैसे फ़ायरफ़ॉक्स, urxvt, ग्रहण, LyX का मुख्य पाठ क्षेत्र) लेकिन कुछ प्रोग्राम कुछ भी नहीं करते हैं जब मैं इन "शॉर्टकट" (जैसे NetBeans और LyX संवाद) का उपयोग करके कर्सर को स्थानांतरित करने की कोशिश करता हूं।

तो, क्या इन अन्य कार्यक्रमों को मेरी इच्छाओं का सम्मान करने का एक तरीका है? और वे पहली जगह में काम क्यों नहीं कर रहे हैं? मैं डीई का उपयोग नहीं कर रहा हूं; केवल बहुत बढ़िया WM।

संपादित करें:

यहाँ एक पूर्ण लेकिन सरलीकृत कीबोर्ड लेआउट फ़ाइल है। मेरे पास यह है /usr/share/X11/xkb/symbols/nonpopऔर मैं इसे लोड करता हूं setxkbmap nonpop।
मैंने देखा कि मोनोडेवल में काम के इर्द-गिर्द घूम रहा है लेकिन चयन नहीं करता है। यही है, अगर मैं Shift + दायां दबाता हूं, तो पाठ हमेशा की तरह चुना जाता है, लेकिन अगर मैं AltGr + Shift + n दबाता हूं, तो कर्सर बस चयन किए बिना चलता है। उदाहरण के लिए फ़ायरफ़ॉक्स में दोनों तरीकों का चयन करने के लिए इस्तेमाल किया जा सकता है।
यहाँ अंत में वे ओवरले के बारे में बात करते हैं जो कुछ ऐसा दिखता है जो शायद एक समाधान हो सकता है लेकिन मुझे नहीं पता है कि उनका उपयोग कैसे करें।

linux keyboard-layout xkb

— nonpop
स्रोत

मैं एक समाधान नहीं है, लेकिन अगर आप इनाम के बावजूद उसका उत्तर मिल का प्रबंधन नहीं करते आप डाल आप कम से पूछ की कोशिश कर सकते unix.SE , एक और अधिक यूनिक्स / लिनक्स केंद्रित Stackexchange साइट।

— Glutanimate

जवाबों:

वे काम क्यों नहीं कर रहे हैं

ArchWiki के लेख के अनुसार जिसका आपने उल्लेख किया है:

एक्स सर्वर इनपुट डिवाइस से कीकोड प्राप्त करता है और उन्हें राज्य और कीसम में परिवर्तित करता है ।
- राज्य X संशोधक (Ctrl / Shift / etc) का बिटमास्क है।
- किरम ( /usr/include/X11/keysymdef.hपूर्णांक) के अनुसार पूर्णांक है
  
  एक कीबोर्ड लेआउट के प्रत्येक कुंजी (जैसे दृश्य उत्कीर्णन के माध्यम से) से जुड़े पात्रों या कार्यों की पहचान करें।
  
  प्रत्येक प्रिंट करने योग्य चरित्र अपने स्वयं के keysym हैं, जैसे plus, a, A, या Cyrillic_aहै, लेकिन अन्य कुंजी भी अपने keysyms, जैसे उत्पन्न Shift_L, Leftया F1।
कुंजी प्रेस / रिलीज की घटनाओं में आवेदन इस जानकारी के सभी हो जाता है।

कुछ एप्लिकेशन Control_Lअपने आप की तरह की-जिम ट्रैक करते हैं, अन्य बस राज्य में संशोधक बिट्स की तलाश करते हैं ।

तो क्या होता है, जब आप AltGr+ दबाते हैं j:

तुम दबाओ AltGr। एप्लिकेशन को Keycode 108 ( <RALT>) और keyym 0xfe03 ( ISO_Level3_Shift) के साथ KeyPressed इवेंट मिलता है , राज्य 0 है।
आप प्रेस j(जो संशोधक के बिना dvorak में "ज" के नक्शे)। एप्लिकेशन को कीकोड 44 ( <AC07>), कीज़ाइम 0xff51 ( Left) और स्टेट 0x80 (मॉडिफ़ायर मॉड 5 चालू है) के साथ KeyPressed इवेंट मिलता है।
आप जारी करते हैं j। एप्लिकेशन को कुंजी के लिए KeyRelease ईवेंट मिलता है <AC07>/ Leftसमान मापदंडों के साथ।
फिर AltGrAltGr के लिए KeyRelease इवेंट जारी करें । (वैसे, यहां की स्थिति अभी भी 0x80 है, लेकिन इससे कोई फर्क नहीं पड़ता।)

यह देखा जा सकता है यदि आप xevउपयोगिता चलाते हैं ।

तो, इसका मतलब यह है कि, हालांकि आवेदन Leftको सामान्य कुंजी से समान कीम कोड ( ) <LEFT>मिलता है, यह AltGr से कीसम कोड और संशोधक राज्य भी प्राप्त करता है। शायद, वे प्रोग्राम जो काम नहीं करते, संशोधक देखते हैं और कुछ सक्रिय होने पर काम नहीं करना चाहते हैं।

उन्हें कैसे काम करना है

जाहिरा तौर पर, हम संशोधक की तलाश नहीं करने के लिए हर कार्यक्रम को बदल नहीं सकते हैं। तब इस स्थिति से बचने का एकमात्र विकल्प संशोधक की कुंजियाँ और राज्य बिट्स उत्पन्न नहीं करना है।

1. अलग समूह

एकमात्र तरीका है कि मेरे दिमाग में आता है: कर्सर आंदोलन चाबियाँ, पूर्व कुंजी का उपयोग करने के लिए एक अलग समूह और स्विच में परिभाषित एक अलग कुंजी प्रेस के साथ उस समूह के लिए j, k, l, i( h, t, n, c) (समूह latching पसंदीदा तरीका है एक बार समूह परिवर्तन के लिए, जैसा कि मैं समझता हूं)।

उदाहरण के लिए:

xkb_keymap {
    xkb_keycodes { include "evdev+aliases(qwerty)" };
    xkb_types { include "complete" };
    xkb_compatibility {
        include "complete"

        interpret ISO_Group_Latch { action = LatchGroup(group=2); };
    };
    xkb_symbols {
        include "pc+us(dvorak)+inet(evdev)"

        key <RALT> { [ ISO_Group_Latch ] };

        key <AC07> {
            type[Group2] = "ONE_LEVEL",
            symbols[Group2] = [ Left ]
        };
        key <AC08> {
            type[Group2] = "ONE_LEVEL",
            symbols[Group2] = [ Down ]
        };
        key <AC09> {
            type[Group2] = "ONE_LEVEL",
            symbols[Group2] = [ Right ]
        };
        key <AD08> {
            type[Group2] = "ONE_LEVEL",
            symbols[Group2] = [ Up ]
        };
    };
    xkb_geometry { include "pc(pc104)" };
};

अब, यदि आप पहली बार AltGrऔर फिर (अलग से) आंदोलन कुंजियों में से एक को दबाते हैं, तो यह काम करना चाहिए।

हालांकि, यह बहुत उपयोगी नहीं है, LockGroup समूह स्विच से पहले और बाद में कुंडी के बजाय अधिक उपयुक्त होगा और AltGr दबाएं। इससे भी बेहतर हो सकता है SetGroup- तब AltGr केवल दबाए जाने के दौरान उस समूह का चयन करेगा, लेकिन यह कि अनुप्रयोगों के लिए प्रकट होता है AltGr की कीज़ाइम ( ISO_Group_Shift/ ISO_Group_Latch/ जो भी परिभाषित किया गया है) (लेकिन संशोधक राज्य साफ रहता है)।

लेकिन ... इस बात की भी संभावना है कि अनुप्रयोग कीकोड (वास्तविक कुंजी के कोड) भी पढ़ता है। तब यह "नकली" कर्सर कुंजियों को नोटिस करेगा।

2. ओवरले

अधिक "निम्न-स्तरीय" समाधान ओवरले होगा (जैसा कि एक ही लेख बताता है)।

ओवरले का सीधा सा मतलब है कि कुछ (असली कीबोर्ड) कुंजी किसी अन्य कुंजी का कीकोड लौटाती है। X सर्वर एक कुंजी के कीकोड को बदलता है और उस नए कीकोड के लिए संशोधक स्थिति और कीज़ाइम की गणना करता है, इसलिए एप्लिकेशन को परिवर्तन को नोटिस नहीं करना चाहिए।

लेकिन ओवरले बहुत सीमित हैं:

एक्स सर्वर में केवल 2 ओवरले कंट्रोल बिट्स होते हैं (यानी अधिकतम 2 ओवरले हो सकते हैं)।
प्रत्येक कुंजी में केवल 1 वैकल्पिक कीकोड हो सकता है।

बाकी के लिए, कार्यान्वयन एक अलग समूह के साथ विधि के समान है:

xkb_keymap {
    xkb_keycodes { include "evdev+aliases(qwerty)" };
    xkb_types { include "complete" };
    xkb_compatibility {
        include "complete"

        interpret Overlay1_Enable {
            action = SetControls(controls=overlay1);
        };
    };
    xkb_symbols {
        include "pc+us(dvorak)+inet(evdev)"

        key <RALT> {
            type[Group1] = "ONE_LEVEL",
            symbols[Group1] = [ Overlay1_Enable ]
        };
        key <AC07> { overlay1 = <LEFT> };
        key <AC08> { overlay1 = <DOWN> };
        key <AC09> { overlay1 = <RGHT> };
        key <AD08> { overlay1 = <UP> };
    };
    xkb_geometry { include "pc(pc104)" };
};

SetControlsइसका मतलब यह है कि कुंजी दबाए जाने पर नियंत्रण बिट को बदलें और कुंजी रिलीज़ पर इसे पुनर्स्थापित करें। समान कार्य होना चाहिए LatchControls, लेकिन xkbcompमुझे देता है

Error:            Unknown action LatchControls

कीमैप संकलन पर।

(वैसे, मैं DVorak का भी उपयोग करता हूं और कुछ आंदोलन की-वर्ड्स को उच्च स्तर की अल्फ़ाबेटिक कुंजियों में भी रीमैप किया है। और कुछ टूटी हुई कार्यक्षमता (Ctrl-Alt-Left / Right द्वारा Xfce नोट्स और डेस्कटॉप स्विच में चयन) के लिए भी धन्यवाद दिया है। आपका सवाल और यह जवाब, अब मुझे पता है कि एक ओवरले क्या है :))

— chel
स्रोत

धन्यवाद! मुझे वास्तव में unix.se पर एक और उत्तर मिला, जो पहली बार में बिल्कुल सही लग रहा था लेकिन कुछ अनुप्रयोगों को अभी भी गलत तरीके से बदल दिया गया। यह समाधान (ओवरले) उन मामलों में भी काम करता है।

— नॉनपॉप

मैंने अभी देखा कि Google क्रोम [e | ium] को इस बात की कोई परवाह नहीं है! :( सौभाग्य से मैं उनका ज्यादा इस्तेमाल नहीं करता।

— nonpop

@nonpop Goddamn क्रोमियम ... मैंने अपने उत्तर में एक अद्यतन जोड़ दिया है superuser.com/a/1000320/521612

— Aleks-Daniel Jakimenko

गजब का! मैंने वर्षों से इसके लिए खोज की है! क्रोमियम के साथ अभी भी एक छोटी सी समस्या है जहां यह एक कीपर की व्याख्या करता है Overlay1_Enable। मेरा यहाँ भी यही लक्षण है: github.com/GalliumOS/galliumos-distro/issues/362

— Tarrasch

मैं सिर्फ उपरोक्त मुद्दे को ठीक करने में कामयाब रहा। मेरे होम रो तीर कुंजी अब क्रोमियम में भी काम करती हैं! मुझे इस उत्तर के लिए निम्नलिखित बदलाव की आवश्यकता थी। gist.github.com/Tarrasch/1293692/...

— Tarrasch

मेरी भी यही समस्या है। यह कितना दर्दनाक है।

तो शीर्षक है "सभी अनुप्रयोगों को मेरे संशोधित xkb लेआउट का सम्मान कैसे करें?"। ठीक है, मुझे लगता है कि एकमात्र तरीका उन सभी कार्यक्रमों को ठीक करना है जो इसे गलत तरीके से करते हैं। चलो करते हैं!

खैर, NetBeans में उस बग की रिपोर्ट करने के बाद ( अपडेट: मैंने नवीनतम संस्करण की कोशिश की है और यह अब काम करता है! ), मैंने सोचा कि मैं हर आवेदन के लिए बस इस बग की रिपोर्ट करता रहूंगा। सूची में अगला आवेदन स्पीडक्रंच था ।

हालांकि, इसी तरह की बग रिपोर्ट देखने के बाद मुझे यह मुद्दा मिला । किसी और को एक ही समस्या हो रही है, महान!

टिप्पणियों को पढ़ने के बाद आप समझेंगे कि यह बग सभी क्यूटी ऐप में मौजूद होना चाहिए। यहाँ एक क्यू बग रिपोर्ट है । हल नहीं किया गया है, लेकिन ऐसा लगता है कि समस्या Qt5 में हल हो गई है ।

हालाँकि, यदि आप टिप्पणियों को देखते हैं, तो वर्कअराउंड है! यहाँ दिया गया है कि यह कैसे काम करता है। यदि आप ऐसा कर रहे थे:

key <SPCE> { [ ISO_Level3_Shift ] };

तो आप इसे इस में बदल सकते हैं:

key <SPCE> {
  type[Group1]="ONE_LEVEL",
  symbols[Group1] = [ ISO_Level3_Shift ]
};

और यह वास्तव में कुछ अनुप्रयोगों के लिए समस्या को हल करेगा! उदाहरण के लिए, स्पीडक्रंच अब मेरे लिए काम करता है! वाह!

सारांश

अभी किसी भी एप्लिकेशन को सही तरीके से काम करना चाहिए। यदि ऐसा नहीं है, तो आपको उपयोग करना होगा type[Group1]="ONE_LEVEL"। यदि आपके पास पहले से ही है, तो आपको अपने सॉफ़्टवेयर को अपडेट करना होगा। यदि यह अभी भी काम नहीं करता है, तो यह ऐप-विशिष्ट है और आपको बग रिपोर्ट प्रस्तुत करनी होगी।

अद्यतन (2017-09-23)

आज तक, सभी एप्लिकेशन मेरे कीबोर्ड लेआउट का सम्मान करते हैं। एक को छोड़कर सभी।

गंभीरता से, क्रोमियम में कीबोर्ड हैंडलिंग कचरा है । इसके साथ कई समस्याएं हैं:

शिफ्ट चयन कस्टम एरो कीज़ के साथ नहीं होता है (लेकिन एरो कीज़ स्वयं ठीक काम करती हैं)
यदि आपके पास कई लेआउट हैं और किसी एक लेआउट पर कुछ कुंजी विशेष है (जैसे तीर, बैकस्पेस, आदि), तो दूसरे लेआउट पर यह कुंजी आपके पहले लेआउट पर जो कुछ भी है, उसे ठीक किया जाएगा। उदाहरण के लिए, आप दो लेआउट अगर: foo, barऔर कुछ प्रमुख में बैकस्पेस करता है foo, तो यह में बैकस्पेस के रूप में काम करता रहेगा bar, भले ही वह वहाँ नए सिरे से परिभाषित किया गया है।

वर्षों तक मैंने क्रोमियम का उपयोग न करके इन समस्याओं को अनदेखा कर दिया। हालांकि, आजकल चीजें इलेक्ट्रॉन का उपयोग करती हैं , जो दुर्भाग्य से क्रोमियम पर बनाया गया है।

इसे हल करने का सही तरीका क्रोमियम में बग रिपोर्ट प्रस्तुत करना और सर्वश्रेष्ठ के लिए आशा करना होगा। मुझे नहीं पता कि उन्हें एक ऐसे मुद्दे को हल करने में कितना समय लगेगा जो केवल कुछ उपयोगकर्ताओं को प्रभावित कर रहा है ... लेकिन यह एकमात्र तरीका है। इसके साथ समस्या यह है कि क्रोमियम वास्तव में neo(de)लेआउट के साथ ठीक काम करता है । नियो लेआउट में स्तर 5 पर तीर कुंजियाँ हैं, लेकिन मैं अपने कस्टम लेआउट में काम करने के लिए इसे प्राप्त नहीं कर सकता।

अभी भी खुले बग रिपोर्ट:

आघात - https://github.com/mate-desktop/pluma/issues/17

— एलेक्स-डैनियल जकीमेंको
स्रोत

जानकारी के लिए धन्यवाद! वर्कअराउंड मेरी मदद नहीं करता है इसलिए मुझे लगता है कि मुझे केवल बग्स की रिपोर्ट करनी होगी और qt5 रूपांतरणों की प्रतीक्षा करनी होगी।

— नॉनपॉप

उन्हें कैसे काम करना है - समाधान 3

अतिरिक्त स्तरों और कार्रवाई का उपयोग करना

निम्नलिखित समाधान jkli पर कर्सर कुंजी प्रदान करने के लिए बायीं Alt कुंजी का उपयोग करता है, होम / एंड / पेजअप / पेजडाउन पर uopö और बैकस्पेस पर एक डिलीट।

अन्य सभी कुंजियों (जैसे एप्लिकेशन मेनू के लिए) के लिए अन्य उद्देश्यों के लिए बाईं ओर Alt कुंजी प्रयोग करने योग्य है। लेफ्ट ऑल्ट (मोड 1) को मॉडिफ़ायर स्टेट से हटा दिया जाता है जब कर्सर ब्लॉक का उपयोग किया जाता है, ताकि एप्लिकेशन इसे देख न सकें।

xkb_keymap {
    xkb_keycodes { 
        include "evdev+aliases(qwertz)" 
    };
    xkb_types { 
        include "complete"  
    };
    xkb_compat { 
        include "complete"
        interpret osfLeft {
            action = RedirectKey(keycode=<LEFT>, clearmodifiers=Mod1);
        };
        interpret osfRight {
            action = RedirectKey(keycode=<RGHT>, clearmodifiers=Mod1);
        };
        interpret osfUp {
            action = RedirectKey(keycode=<UP>, clearmodifiers=Mod1);
        };
        interpret osfDown {
            action = RedirectKey(keycode=<DOWN>, clearmodifiers=Mod1);
        };
        interpret osfBeginLine {
            action = RedirectKey(keycode=<HOME>, clearmodifiers=Mod1);
        };
        interpret osfEndLine {
            action = RedirectKey(keycode=<END>, clearmodifiers=Mod1);
        };
        interpret osfPageUp {
            action = RedirectKey(keycode=<PGUP>, clearmodifiers=Mod1);
        };
        interpret osfPageDown {
            action = RedirectKey(keycode=<PGDN>, clearmodifiers=Mod1);
        };
        interpret osfDelete {
            action = RedirectKey(keycode=<DELE>, clearmodifiers=Mod1);
        };
    };
    xkb_symbols { 
        include "pc+de(nodeadkeys)"
        include "inet(evdev)"
        include "compose(rwin)"
        key <LALT> {
            type[Group1] = "ONE_LEVEL",
            symbols[Group1] = [ ISO_Level5_Shift ]
        };
        modifier_map Mod1 { <LALT> };
        key <AC07> {
            type[Group1] = "EIGHT_LEVEL_SEMIALPHABETIC",
            symbols[Group1] = [ j, J, dead_belowdot, dead_abovedot, osfLeft, osfLeft, osfLeft, osfLeft ]
        };
        key <AC08> {
            type[Group1] = "EIGHT_LEVEL_SEMIALPHABETIC",
            symbols[Group1] = [ k, K, kra, ampersand, osfDown, osfDown, osfDown, osfDown ]
        };
        key <AC09> {
            type[Group1] = "EIGHT_LEVEL_ALPHABETIC",
            symbols[Group1] = [ l, L, lstroke, Lstroke, osfRight, osfRight, osfRight, osfRight ]
        };
        key <AC10> {
            type[Group1] = "EIGHT_LEVEL_SEMIALPHABETIC",
            symbols[Group1] = [ odiaeresis, Odiaeresis, doubleacute, doubleacute, osfPageDown, osfPageDown, osfPageDown, osfPageDown ]
        };
        key <AD07> {
            type[Group1] = "EIGHT_LEVEL_SEMIALPHABETIC",
            symbols[Group1] = [ u, U, downarrow, uparrow, osfBeginLine, osfBeginLine, osfBeginLine, osfBeginLine ]
        };
        key <AD08> {
            type[Group1] = "EIGHT_LEVEL_SEMIALPHABETIC",
            symbols[Group1] = [ i, I, rightarrow, idotless, osfUp, osfUp, osfUp, osfUp ]
        };
        key <AD09> {
            type[Group1] = "EIGHT_LEVEL_ALPHABETIC",
            symbols[Group1] = [ o, O, oslash, Oslash, osfEndLine, osfEndLine, osfEndLine, osfEndLine ]
        };
        key <AD10> {
            type[Group1] = "EIGHT_LEVEL_ALPHABETIC",
            symbols[Group1] = [ p, P, thorn, THORN, osfPageUp, osfPageUp, osfPageUp, osfPageUp ]
        };
        key <BKSP> {
            type[Group1] = "EIGHT_LEVEL_ALPHABETIC",
            symbols[Group1] = [ BackSpace, BackSpace, BackSpace, BackSpace, osfDelete, osfDelete, osfDelete, osfDelete ] 
        };
    };
    xkb_geometry { 
        include "pc(pc105)" 
    };
};

— MGL
स्रोत

पवित्र मोली! यह वास्तव में काम करता है! यह क्रोमियम जैसे टूटे हुए अनुप्रयोगों के आसपास काम करता है। क्या आप बता सकते हैं कि ये ऑसफ परिभाषाएं क्या हैं? ऐसा लगता है कि वे पूर्वनिर्धारित हैं ताकि आप उन्हें यादृच्छिक रूप से नाम न दे सकें।

— एलेक्स-डैनियल जकीमेंको