यी के लिए मेनू

हाल ही में, मैंने अभी भी विम और एमाक्स के समान एक पाठ संपादक यी के साथ बैठकर व्यवहार करने का फैसला किया, लेकिन हास्केल में लिखा गया। किट में विम और इमैक सिमुलेशन भी हैं।
Vim या Emacs के साथ अनुभव की कमी के कारण, केवल Cua- अनुकार ने मुझे अनुकूल बनाया। वहाँ कुछ हॉटकीज़ हैं, लेकिन वे मुझसे परिचित हैं। इसलिए मैंने इसके साथ शुरुआत करने और अपने लिए एक सेटिंग लिखने का फैसला किया।
साधारण ग्राफिक संपादकों में, यह मुझे मेनू का उपयोग करने का एक सुविधाजनक तरीका लगता है। Alt दबाएं, एक मेनू खुलता है, जहां प्रत्येक तत्व में एक अक्षर रेखांकित होता है, जिस पर क्लिक करके हम इस तत्व का चयन करेंगे।
इस प्रकार, एक बार में सभी कमांड को याद रखना आवश्यक नहीं है, लेकिन आप मेनू में झांककर इसका उपयोग करना शुरू कर सकते हैं, धीरे-धीरे इसे स्वचालितता में ला सकते हैं।
मैंने यी में भी कुछ ऐसा ही करने का फैसला किया।

हमने साधारण हॉटकीज़ की स्थापना की

सबसे पहले आपको यह पता लगाना होगा कि यी कैसे काम करता है। इसे समझने का सबसे आसान तरीका है यदि आप तैयार किए गए बाइंडरों को देखें, जैसे कि कुआ । यह छोटा, और विम और एमएसीएस एनालॉग बाँधने की तुलना में बहुत अधिक आदिम है, लेकिन हमारे उद्देश्यों के लिए (अपने खुद के लिखने के लिए) - यही है।

सबसे पहले, आइए ध्यान दें कि हॉटकीज़ को आम तौर पर कैसे परिभाषित किया जाता है। इसे मुख्य कार्य द्वारा देखा जा सकता है।

keymap :: KeymapSet keymap = portableKeymap ctrl -- | Introduce a keymap that is compatible with both windows and osx, -- by parameterising the event modifier required for commands portableKeymap :: (Event -> Event) -> KeymapSet portableKeymap cmd = modelessKeymapSet $ selfInsertKeymap <|> move <|> select <|> rect <|> other cmd 

अलग-अलग बाध्यकारी विकल्पों को <|> ऑपरेटर के उपयोग से संयोजित किया जाता है। आइए आगे देखें अन्य cmd:

 other cmd = choice [ spec KBS ?>>! deleteSel bdeleteB, spec KDel ?>>! deleteSel (deleteN 1), spec KEnter ?>>! replaceSel "\n", cmd (char 'q') ?>>! askQuitEditor, cmd (char 'f') ?>> isearchKeymap Forward, cmd (char 'x') ?>>! cut, cmd (char 'c') ?>>! copy, cmd (char 'v') ?>>! paste, cmd (spec KIns) ?>>! copy, shift (spec KIns) ?>>! paste, cmd (char 'z') ?>>! undoB, cmd (char 'y') ?>>! redoB, cmd (char 's') ?>>! fwriteE, cmd (char 'o') ?>>! findFile, cmd (char '/') ?>>! withModeB modeToggleCommentSelection, cmd (char ']') ?>>! autoIndentB IncreaseOnly, cmd (char '[') ?>>! autoIndentB DecreaseOnly ] 

जैसा कि आप देख सकते हैं, कुंजी संयोजन बाईं ओर है और कार्रवाई दाईं ओर है। यानी जब आप cmd (char 'c') दबाते हैं (डिफ़ॉल्ट cmd ctrl है) - हमें कॉपी मिलती है, जिसका कोड भी सीधा है।

मैंने इन परिभाषाओं को खुद को कॉपी किया और किसी तरह का मेनू बनाने के लिए उन्हें संपादित करना शुरू करने का फैसला किया।

मेनू कैसे बनाएं?

मेनू को कैसे लागू किया जाए, यह तय करने के लिए, आपको मॉड्यूल के प्रलेखन पर जाना चाहिए। सब कुछ काफी आसानी से संरचित है, और Yi.MiniBuffer मॉड्यूल आपकी आंख को पकड़ता है। जाहिर है, यह वही है जो हमें चाहिए। एक फंक्शन है

 spawnMinibufferE :: String -> KeymapEndo -> EditorM BufferRef 

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

सबसे पहले, एक प्रकार बनाएं जो मेनू का वर्णन करने के लिए सुविधाजनक है। मेनू में आइटमों की एक सूची होती है, जिनमें से प्रत्येक या तो एक सबमेनू खोलती है, या किसी प्रकार की कार्रवाई होती है। तो हम लिखते हैं:

 -- | Menu type Menu = [MenuItem] -- | Menu utem data MenuItem = MenuAction String (MenuContext -> Char -> Keymap) | SubMenu String Menu -- | Menu action context data MenuContext = MenuContext { parentBuffer :: BufferRef } 

सबमेनू वेरिएंट में एक शीर्षक और एक सबमेनू होता है, मेन्यूएशन संस्करण में एक शीर्षक और एक फ़ंक्शन होता है जो आवश्यक बाँध बनाता है।
MenuContext एक निश्चित संदर्भ है जिसे क्रियाओं में स्थानांतरित किया जाता है (अब तक केवल स्रोत बफर है जिसमें से मेनू को बुलाया गया था, इसे सेव बटन को लागू करने के लिए आवश्यक था), चार वह बटन है जिस पर क्लिक करके मेनू को बुलाया जाना चाहिए।

चूंकि प्रकार पुनरावर्ती है, आप बस इसके लिए एक दृढ़ संकल्प को परिभाषित कर सकते हैं, ताकि बाद में, इसका उपयोग करके, मेनू शुरू करें:

 -- | Fold menu item foldItem :: (String -> (MenuContext -> Char -> Keymap) -> a) -> (String -> [a] -> a) -> MenuItem -> a foldItem mA sM (MenuAction title act) = mA title act foldItem mA sM (SubMenu title sm) = sM title (map (foldItem mA sM) sm) -- | Fold menu foldMenu :: (String -> (MenuContext -> Char -> Keymap) -> a) -> (String -> [a] -> a) -> Menu -> [a] foldMenu mA sM = map (foldItem mA sM) 

हमें ऐसे कार्यों की भी आवश्यकता होगी जो हमारे लिए अधिक सुविधाजनक रूप से मेनू आइटम बनाते हैं। SubMenu बनाना आसान है, SubMenu "फाइल" है ... लेकिन MenuAction का उपयोग करना कठिन है। इसलिए, हम कई कार्यों को परिभाषित करते हैं जो कार्रवाई करेंगे (उसी के दाईं ओर? >> बाइंडर्स में)। मैं उनमें से दो का एक कोड दूंगा:

 -- | Action on item action_ :: (YiAction ax, Show x) => String -> a -> MenuItem action_ title act = action title (const act) -- | Action on item with context action :: (YiAction ax, Show x) => String -> (MenuContext -> a) -> MenuItem action title act = MenuAction title act' where act' ctx c = char c ?>>! (do withEditor closeBufferAndWindowE runAction $ makeAction (act ctx)) 

यहां हम एक MenuItem बनाते हैं, जब आप उपयुक्त बटन (चार सी) पर क्लिक करते हैं, तो मेनू को बंद कर देता है और हमें आवश्यक कार्रवाई को आमंत्रित करता है।

और अंत में, हम एक मेनू डिस्प्ले फ़ंक्शन लिखेंगे।

 -- | Start menu action startMenu :: Menu -> EditorM () startMenu m = do --  ,   ctx <- fmap MenuContext (gets currentBuffer) startMenu' ctx m where --  ,      (, ) startMenu' ctx = showMenu . foldMenu onItem onSub where showMenu :: [(String, Maybe Keymap)] -> EditorM () --   —      ,    showMenu is = void $ spawnMinibufferE menuItems (const (subMap is)) where menuItems = (intercalate " " (map fst is)) --    — --   +    ,   onItem title act = (title, fmap (act ctx) (menuEvent title)) where --    — --  +  ,        onSub title is = (title, fmap subMenu (menuEvent title)) where --  'c'        subMenu c = char c ?>>! closeBufferAndWindowE >> showMenu is --        Esc,        subMap is = choice $ closeMenu : mapMaybe snd is where closeMenu = spec KEsc ?>>! closeBufferAndWindowE 

पूरा कोड यहां पाया जा सकता है ।

एक मेनू बनाएँ

अब यह किसी प्रकार का मेनू बनाने लायक है, इसे एक बटन से जोड़ना और आप जाँच शुरू कर सकते हैं।
सबसे पहले, मैंने एक बड़े, पत्तेदार मेनू को लिखा, जो मुझे यी में विभिन्न मॉड्यूलों को देखते हुए भर आया था। जब मैंने देखा कि, उदाहरण के लिए, मैं अक्सर व्यू - विंडोज सबमेनू पर जाता हूं, तो मैंने इस मेनू को एक अलग हॉटकी पर रखने का फैसला किया।
अब आप न केवल लंबे VWS संयोजन से विंडो को विभाजित कर सकते हैं, बल्कि सिर्फ Ctrl-W - S भी।

यहाँ मुख्य मेनू और विंडोज के सबमेनू के लिए कोड है:

 -- | Main menu mainMenu :: Menu mainMenu = [ menu "File" [ action_ "Quit" askQuitEditor, action "Save" (fwriteBufferE . parentBuffer)], menu "Edit" [ action_ "Auto complete" wordComplete, action_ "Completion" completeWordB], menu "Tools" [ menu "Ghci" ghciMenu], menu "View" [ menu "Windows" windowsMenu, menu "Tabs" tabsMenu, menu "Buffers" buffersMenu, menu "Layout" [ action_ "Next" layoutManagersNextE, action_ "Previous" layoutManagersPreviousE]]] -- | Windows menu windowsMenu :: Menu windowsMenu = [ action_ "Next" nextWinE, action_ "Previous" prevWinE, action_ "Split" splitE, action_ "sWap" swapWinWithFirstE, action_ "Close" tryCloseE, action_ "cLose-all-but-this" closeOtherE] 

पूरे मेनू को यहां देखा जा सकता है ।

परिणाम

हम विभिन्न संयोजनों के लिए मुख्य मेनू और सबमेनू निर्धारित करते हैं।

हम इसका उपयोग कर रहे हैं!

परिणाम

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

सभी कोड GitHub पर उपलब्ध है ।

अद्यतन

तीन कार्यों actionB , actionE और actionY की उपस्थिति actionY । हालांकि, उन्हें runAction . makeAction बदला जा सकता है runAction . makeAction runAction . makeAction
एकल क्रिया के लिए निश्चित