मैं विम में दो खुली फाइलों (स्प्लिट्स में) की स्थिति को कैसे स्वैप कर सकता हूं?


313

मान लें कि मुझे vim में विभाजन के कुछ मनमाने लेआउट मिले हैं।

____________________
| one       | two  |
|           |      |
|           |______|
|           | three|
|           |      |
|___________|______|

वहाँ एक तरह से स्वैप oneऔर twoएक ही लेआउट बनाए रखने के लिए है? यह इस उदाहरण में सरल है, लेकिन मैं एक समाधान ढूंढ रहा हूं जो अधिक जटिल लेआउट के लिए मदद करेगा।

अपडेट करें:

मुझे लगता है कि मुझे अधिक स्पष्ट होना चाहिए। मेरा पिछला उदाहरण वास्तविक उपयोग-मामले का सरलीकरण था। वास्तविक उदाहरण के साथ: वैकल्पिक शब्द

मैं उन दोनों स्प्लिट्स में से किसी एक को कैसे स्वैप कर सकता हूं, उसी लेआउट को बनाए रखना?

अपडेट करें! 3+ साल बाद ...

मैं एक Vim प्लगइन में आप आसानी से स्थापित कर सकते हैं sgriffin के समाधान डाल दिया! अपने पसंदीदा प्लगइन प्रबंधक के साथ इसे स्थापित करें और इसे आज़माएं: WindowSwap.vim

थोड़ा डेमो


14
यदि आप दो मिनट पहले मेरे बारे में सोच रहे हैं तो "क्या मुझे वास्तव में इसके लिए प्लगइन की आवश्यकता है?", झिझक बंद करें और इसे स्थापित करें। मूल रूप से सिर्फ एक कमांड है: <नेता> ww जो आप दो बार दबाते हैं, एक बार प्रत्येक विंडो में स्वैप करने के लिए। यह सुपर-आसान है और आप 30 सेकंड में चलेंगे।
mdup

जवाबों:


227

पोस्ट के लिए थोड़ा देर हो गई, लेकिन यह कुछ और की खोज में आया। मैंने एक विंडो को चिह्नित करने और फिर खिड़कियों के बीच बफ़र्स को स्वैप करने के लिए दो कार्यों को थोड़ी देर लिखा। ऐसा लगता है कि आप क्या पूछ रहे हैं।

बस अपने .vimrc में इन्हें थप्पड़ मारें और उन कार्यों को मैप करें जिन्हें आप फिट देखते हैं:

function! MarkWindowSwap()
    let g:markedWinNum = winnr()
endfunction

function! DoWindowSwap()
    "Mark destination
    let curNum = winnr()
    let curBuf = bufnr( "%" )
    exe g:markedWinNum . "wincmd w"
    "Switch to source and shuffle dest->source
    let markedBuf = bufnr( "%" )
    "Hide and open so that we aren't prompted and keep history
    exe 'hide buf' curBuf
    "Switch to dest and shuffle source->dest
    exe curNum . "wincmd w"
    "Hide and open so that we aren't prompted and keep history
    exe 'hide buf' markedBuf 
endfunction

nmap <silent> <leader>mw :call MarkWindowSwap()<CR>
nmap <silent> <leader>pw :call DoWindowSwap()<CR>

उपयोग करने के लिए (मान लीजिए कि आपका मापक आपके लिए निर्धारित है):

  1. स्वैप के माध्यम से चिह्नित करने के लिए विंडो पर जाएं Ctrl-w आंदोलन के
  2. प्रकार \ mw
  3. उस विंडो पर जाएं जिसे आप स्वैप करना चाहते हैं
  4. टाइप करें \ pw

देखा! अपने विंडो लेआउट को खराब किए बिना स्वैप किए गए बफ़र्स!


17
काश मैं तुम्हें दस बार उखाड़ सकता! मुझे noremapइसे बनाने के लिए मैपिंग में उपयोग करना पड़ा। यकीन नहीं क्यों, लेकिन उम्मीद है कि किसी को भी जो बाद में यह पता चलता है मदद करता है। : डी
वेस

6
मैंने अपना समाधान मेरे पहले विम प्लगइन में डाला: WindowSwap.vim में डाला । मैंने इस प्रश्न और आपके उत्तर को रीडमी में जोड़ा: डी
वेस

मैंने कुछ साल पहले अपने .vimrc में sgriffin का समाधान डाला, और मैं वर्तमान में सफाई कर रहा हूं, और सभी को एक प्लगइन में स्थानांतरित करने का निर्णय लिया। मैंने निष्कर्षण किया, और यह परीक्षण करने के लिए कि यह अभी भी एक बंडल के रूप में काम करता है, मैंने खिड़की को कई बार विभाजित किया, और कुछ भाग गया0r!figlet one [दो, तीन, आदि] को , फिर इसका परीक्षण किया। आगे बढ़ने से पहले मैंने गितुब की जाँच की, आपका (wes ') प्लगइन पाया, एनिमेटेड अंजीर खिड़की स्वैप के साथ, और इसी उत्तर के लिए एक लिंक (जो मुझे मेरे .vimrc में एक टिप्पणी के रूप में था)। मुझे ऐसा लगा कि मैंने पहले ही इसे बना लिया है और इसे अपलोड कर दिया है, और फिर इसके बारे में भूल गया। वैसे भी, अच्छा काम! मुझे कुछ काम बचाता है :)
गैरी फिक्सेलर

293

इसके साथ शुरू:

____________________
| one       | two  |
|           |      |
|           |______|
|           | three|
|           |      |
|___________|______|

'तीन' सक्रिय विंडो बनाएं, फिर कमांड ctrl+ जारी करें w J। यह स्क्रीन के निचले हिस्से को भरने के लिए वर्तमान विंडो को स्थानांतरित करता है, जो आपको छोड़ देता है:

____________________
| one       | two  |
|           |      |
|___________|______|
| three            |
|                  |
|__________________|

अब या तो 'एक' या 'दो' सक्रिय विंडो बनाएं, फिर कमांड ctrl+ जारी करें w r। यह वर्तमान पंक्ति में 'घूमता है'

____________________
| two       | one  |
|           |      |
|___________|______|
| three            |
|                  |
|__________________|

अब 'दो' को सक्रिय विंडो बनाएँ, और कमांड ctrl+ जारी करें w H। यह स्क्रीन के बाईं ओर भरने के लिए वर्तमान विंडो को स्थानांतरित करता है, जो आपको छोड़कर जा रहा है:

____________________
| two       | one  |
|           |      |
|           |______|
|           | three|
|           |      |
|___________|______|

जैसा कि आप देख सकते हैं, manouevre थोड़ा सा फेरबदल है। 3 खिड़कियों के साथ, यह उन 'टाइल गेम' पहेलियों में से एक जैसा है। यदि आपके पास 4 या अधिक विंडो हैं, तो मैं यह कोशिश करने की अनुशंसा नहीं करता - आप उन्हें बंद करना बेहतर होगा, फिर उन्हें वांछित पदों पर फिर से खोलेंगे।

मैंने यह दिखाते हुए एक पेंचकस बनाया कि विम में विभाजित खिड़कियों के साथ कैसे काम किया जाए


2
आप एक शिकंजा, नेलस्ट्रॉम बनाते हुए अतिरिक्त मील गए, लेकिन यह वास्तव में नहीं है जो मैं देख रहा था। मैं मूल आंदोलन आदेशों के साथ विभाजन के साथ काम कर सकता हूं, लेकिन मैं उत्सुक हूं कि अगर मनमाने ढंग से जटिलता के लेआउट में विभाजित स्थानों को स्वैप करने का कोई तरीका है।
वेस

95
मेरे जैसे लोगों के लिए, बस दो विंडो स्वैप करने का तरीका सीखना चाहते हैं: ctrl-w rएक आकर्षण की तरह काम करता है। टिप के लिए आपका धन्यवाद! यहाँ मेरा +1 है।
ेरेऑन

मैंने \mw/ \pwऔर इस एक दोनों को उखाड़ फेंका और एक सप्ताह तक दोनों का उपयोग करने की कोशिश की। मैंने पाया कि यह "देशी" समाधान सबसे अच्छा काम करता है, क्योंकि मुझे सर्वर और रिमोट मशीन और डेस्कटॉप, लैपटॉप, टैबलेट और अन्य सभी डिवाइसों पर स्थापित पंद्रह दर्जन विम इंस्टाल में प्लगइन्स को स्थापित करने की आवश्यकता नहीं है। IOW, इन मूल आदेशों (जैसे ctrl-w r) को सीखना वास्तव में आप सभी को स्मृति की मांसपेशियों के लिए प्रतिबद्ध होने और किए जाने की आवश्यकता है।
eduncan911

96

पर एक नज़र डालें :h ctrl-w_ctrl-xऔर / या:h ctrl-w_ctrl-r । ये आदेश आपको वर्तमान लेआउट में विंडोज़ का आदान-प्रदान या घूमने की अनुमति देते हैं।

संपादित करें: वास्तव में, यह इस स्थिति में काम नहीं करेगा क्योंकि यह केवल वर्तमान कॉलम या पंक्ति में स्वैप करेगा। आप इसके बजाय प्रत्येक विंडो पर जा सकते हैं और लक्ष्य बफर का चयन कर सकते हैं, लेकिन यह बहुत ही क्रियात्मक है।


30

उस में रैंडी का सहीCTRL-W x एक ही स्तंभ / पंक्ति में नहीं हैं खिड़कियों को स्वैप करना चाहते हैं।

मैंने पाया है कि CTRL-W HJKLविंडोज़ में हेरफेर करते समय चाबियाँ सबसे अधिक उपयोगी होती हैं। वे आपकी वर्तमान विंडो को उसके वर्तमान स्थान से बाहर कर देंगे और उसे बताएंगे कि आप जिस कुंजी को दबाते हैं उसकी दिशा में इंगित पूरे किनारे पर कब्जा कर लें। :help window-movingअधिक जानकारी के लिए देखें।

उपरोक्त उदाहरण के लिए, यदि आप विंडो "एक" में शुरू करते हैं, तो यह वही है जो आप चाहते हैं:

CTRL-W K   # moves window "one" to be topmost,
           #   stacking "one", "two", "three" top to bottom
CTRL-W j   # moves cursor to window "two"
CTRL-W H   # moves window "two" to be leftmost,
           #   leaving "one" and "three" split at right

सुविधा के लिए, आप उन दृश्यों को असाइन कर सकते हैं जिनकी आपको कुंजी मैपिंग (देखने :help mapping) की आवश्यकता है।


10

मेरे पास sgriffin के समाधान से थोड़ा बढ़ा हुआ संस्करण है, आप दो कमांड का उपयोग किए बिना विंडोज़ स्वैप कर सकते हैं, लेकिन सहज एचजेकेएल कमांड के साथ।

तो यहाँ है कि यह कैसे जाता है:

function! MarkWindowSwap()
    " marked window number
    let g:markedWinNum = winnr()
    let g:markedBufNum = bufnr("%")
endfunction

function! DoWindowSwap()
    let curWinNum = winnr()
    let curBufNum = bufnr("%")
    " Switch focus to marked window
    exe g:markedWinNum . "wincmd w"

    " Load current buffer on marked window
    exe 'hide buf' curBufNum

    " Switch focus to current window
    exe curWinNum . "wincmd w"

    " Load marked buffer on current window
    exe 'hide buf' g:markedBufNum
endfunction

nnoremap H :call MarkWindowSwap()<CR> <C-w>h :call DoWindowSwap()<CR>
nnoremap J :call MarkWindowSwap()<CR> <C-w>j :call DoWindowSwap()<CR>
nnoremap K :call MarkWindowSwap()<CR> <C-w>k :call DoWindowSwap()<CR>
nnoremap L :call MarkWindowSwap()<CR> <C-w>l :call DoWindowSwap()<CR>

सामान्य नोड में पूंजी HJKL का उपयोग करके अपनी विंडो को स्थानांतरित करने का प्रयास करें, यह वास्तव में अच्छा है :)


3

@ Sgriffin के उत्तर पर भारी निर्माण करना , यहाँ कुछ इस बात के करीब है कि आप क्या माँग रहे हैं:

function! MarkWindow()
        let g:markedWinNum = winnr()
endfunction

function! SwapBufferWithMarkedWindow()
        " Capture current window and buffer
        let curWinNum = winnr()
        let curBufNum = bufnr("%")

        " Switch to marked window, mark buffer, and open current buffer
        execute g:markedWinNum . "wincmd w"
        let markedBufNum = bufnr("%")
        execute "hide buf" curBufNum

        " Switch back to current window and open marked buffer
        execute curWinNum . "wincmd w"
        execute "hide buf" markedBufNum
endfunction

function! CloseMarkedWindow()
        " Capture current window
        let curWinNum = winnr()

        " Switch to marked window and close it, then switch back to current window
        execute g:markedWinNum . "wincmd w"
        execute "hide close"
        execute "wincmd p"
endfunction

function! MoveWindowLeft()
        call MarkWindow()
        execute "wincmd h"
        if winnr() == g:markedWinNum
                execute "wincmd H"
        else
                let g:markedWinNum += 1
                execute "wincmd s"
                execute g:markedWinNum . "wincmd w"
                execute "wincmd h"
                call SwapBufferWithMarkedWindow()
                call CloseMarkedWindow()
        endif
endfunction

function! MoveWindowDown()
        call MarkWindow()
        execute "wincmd j"
        if winnr() == g:markedWinNum
                execute "wincmd J"
        else
                execute "wincmd v"
                execute g:markedWinNum . "wincmd w"
                execute "wincmd j"
                call SwapBufferWithMarkedWindow()
                call CloseMarkedWindow()
        endif
endfunction

function! MoveWindowUp()
        call MarkWindow()
        execute "wincmd k"
        if winnr() == g:markedWinNum
                execute "wincmd K"
        else
                let g:markedWinNum += 1
                execute "wincmd v"
                execute g:markedWinNum . "wincmd w"
                execute "wincmd k"
                call SwapBufferWithMarkedWindow()
                call CloseMarkedWindow()
        endif
endfunction

function! MoveWindowRight()
        call MarkWindow()
        execute "wincmd l"
        if winnr() == g:markedWinNum
                execute "wincmd L"
        else
                execute "wincmd s"
                execute g:markedWinNum . "wincmd w"
                execute "wincmd l"
                call SwapBufferWithMarkedWindow()
                call CloseMarkedWindow()
        endif
endfunction

nnoremap <silent> <Leader>wm :call MarkWindow()<CR>
nnoremap <silent> <Leader>ws :call SwapBufferWithMarkedWindow()<CR>
nnoremap <silent> <Leader>wh :call MoveWindowLeft()<CR>
nnoremap <silent> <Leader>wj :call MoveWindowDown()<CR>
nnoremap <silent> <Leader>wk :call MoveWindowUp()<CR>
nnoremap <silent> <Leader>wl :call MoveWindowRight()<CR>

कृपया मुझे बताएं कि क्या व्यवहार आपकी अपेक्षाओं से मेल नहीं खाता है।


2

इसके अलावा sgriffin के समाधान के आधार पर, उस विंडो पर जाएं जिसे आप स्वैप करना चाहते हैं, दबाएं CTRL-w m, उस विंडो पर जाएं जिसे आप स्वैप करना चाहते हैं और दबाएंCTRL-w m फिर से ।

CTRL-w m एक खराब महामारी पसंद है, इसलिए यदि कोई भी एक बेहतर के साथ आता है, तो कृपया इसे संपादित करें।

इसके अलावा, मैं स्क्रिप्ट उर्फ ​​"विंडो चिह्नित। कृपया लक्ष्य पर दोहराएं" से एक प्रतिक्रिया प्राप्त करना चाहता हूं, हालांकि एक vimscript noob होने के नाते, मुझे नहीं पता कि यह कैसे करना है।

सभी ने कहा, स्क्रिप्ट अच्छी तरह से काम करती है

" <CTRL>-w m : mark first window
" <CTRL>-w m : swap with that window
let s:markedWinNum = -1

function! MarkWindowSwap()
    let s:markedWinNum = winnr()
endfunction

function! DoWindowSwap()
    "Mark destination
    let curNum = winnr()
    let curBuf = bufnr( "%" )
    exe s:markedWinNum . "wincmd w"
    "Switch to source and shuffle dest->source
    let markedBuf = bufnr( "%" )
    "Hide and open so that we aren't prompted and keep history
    exe 'hide buf' curBuf
    "Switch to dest and shuffle source->dest
    exe curNum . "wincmd w"
    "Hide and open so that we aren't prompted and keep history
    exe 'hide buf' markedBuf
endfunction

function! WindowSwapping()
    if s:markedWinNum == -1
        call MarkWindowSwap()
    else
        call DoWindowSwap()
        let s:markedWinNum = -1
    endif
endfunction

nnoremap <C-w>m :call WindowSwapping()<CR>

1

यदि किसी कारण से कार्य उपलब्ध नहीं हैं, तो निम्नलिखित दृष्टिकोण सुविधाजनक हो सकता है (क्योंकि यह आपकी व्यर्थता नहीं है)।

:buffersओपन बफ़र्स का पता लगाने के लिए कमांड का उपयोग करें , वांछित विंडो पर नेविगेट करें और :b 5एक बफर खोलने के लिए कमांड का उपयोग करें (इस मामले में बफर नंबर 5)। दो बार दोहराएं और खिड़कियों की सामग्री स्वैप की जाती है।

मैंने ctrl-w-somethingमूल प्रश्न में एक-दो-तीन जैसे बहुत सरल लेआउट के लिए भी अनुक्रम याद करने के कई प्रयासों के बाद इस पद्धति का "आविष्कार" किया ।


1

वास्तव में अच्छा है, लेकिन मैपिंग के लिए मेरा प्रस्ताव है कि ^ के बजाय ^ ^ ^ J का उपयोग करें (क्योंकि HJKL के सभी पहले से ही अर्थ हैं), साथ ही मैं नए बफर में भी खींचूंगा , क्योंकि जब तक आप अपने चारों ओर स्वैप करना चाहते हैं शायद आप पहले से मौजूद बफ़र को संपादित करना जारी नहीं रखना चाहते। यहाँ जाता हैं:

function! MarkSwapAway()
    " marked window number
    let g:markedOldWinNum = winnr()
    let g:markedOldBufNum = bufnr("%")
endfunction
function! DoWindowToss()
    let newWinNum = winnr()
    let newBufNum = bufnr("%")
    " Switch focus to marked window
    exe g:markedOldWinNum . "wincmd w"
    " Load current buffer on marked window
    exe 'hide buf' newBufNum
    " Switch focus to current window
    exe newWinNum . "wincmd w"
    " Load marked buffer on current window
    exe 'hide buf' g:markedOldBufNum
    " …and come back to the new one
    exe g:markedOldWinNum . "wincmd w"
endfunction
nnoremap <C-w><C-h> :call MarkSwapAway()<CR> <C-w>h :call DoWindowToss()<CR>
nnoremap <C-w><C-j> :call MarkSwapAway()<CR> <C-w>j :call DoWindowToss()<CR>
nnoremap <C-w><C-k> :call MarkSwapAway()<CR> <C-w>k :call DoWindowToss()<CR>
nnoremap <C-w><C-l> :call MarkSwapAway()<CR> <C-w>l :call DoWindowToss()<CR>

1

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

समाधान

इसलिए मैंने स्वैप करने से पहले इन सभी विंडो को बंद करने के लिए कोड की एक अतिरिक्त लाइन जोड़ी।

exe ':windo if &buftype == "quickfix" || &buftype == "locationlist" | lclose | endif'

कुल कोड की तरह लग रही;

" Making swapping windows easy
function! SwapWindowBuffers()
    exe ':windo if &buftype == "quickfix" || &buftype == "locationlist" | lclose | endif'
    if !exists("g:markedWinNum")
        " set window marked for swap
        let g:markedWinNum = winnr()
        :echo "window marked for swap"
    else
        " mark destination
        let curNum = winnr()
        let curBuf = bufnr( "%" )
        if g:markedWinNum == curNum
            :echo "window unmarked for swap"
        else
            exe g:markedWinNum . "wincmd w"
            " switch to source and shuffle dest->source
            let markedBuf = bufnr( "%" )
            " hide and open so that we aren't prompted and keep history
            exe 'hide buf' curBuf
            " switch to dest and shuffle source->dest
            exe curNum . "wincmd w"
            " hide and open so that we aren't prompted and keep history
            exe 'hide buf' markedBuf
            :echo "windows swapped"
        endif
        " unset window marked for swap
        unlet g:markedWinNum
    endif
endfunction

nmap <silent> <leader>mw :call SwapWindowBuffers()<CR>

ब्रैंडन ऑथर को स्वैप समारोह का श्रेय

इसकी आवश्यकता क्यों है

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

इस अप्रभावी को लगाने के लिए:

पहला विंडो मार्क

____________________
| one              | -> winnr = 1    marked first    g:markedWinNum=1
|                  | -> bufnr = 1
|__________________|
| two (QF window   | -> winnr = 2
| coupled to one   |
|__________________|
| three            | -> winnr = 3
|                  | -> bufnr = 2
|__________________|

दूसरी खिड़की का निशान

____________________
| one              | -> winnr = 1                    g:markedWinNum=1
|                  | -> bufnr = 1
|__________________|
| two (QF window   | -> winnr = 2
| coupled to one)  |
|__________________|
| three            | -> winnr = 3    marked second    curNum=3
|                  | -> bufnr = 2                     curBuf=2
|__________________|

पहला बफर स्विच, विंडो एक विंडो तीन के बफर से भरा है। इस प्रकार QF विंडो को हटा दिया जाता है क्योंकि इसमें कोई मूल विंडो नहीं है। यह विंडोज़ संख्याओं को पुन: व्यवस्थित करता है। ध्यान दें कि curNum (दूसरी चयनित विंडो की संख्या) एक ऐसी विंडो की ओर इशारा करती है जिसमें कोई और मौजूद नहीं है।

____________________
| three            | -> winnr = 1                    g:markedWinNum=1
|                  | -> bufnr = 2
|__________________|
| three            | -> winnr = 2                     curNum=3
|                  | -> bufnr = 2                     curBuf=2
|__________________|

इसलिए जब दूसरे बफर को स्विच करते हैं, तो यह कर्नम विंडो का चयन करने की कोशिश करता है, जो किसी भी अधिक मौजूद नहीं है। तो यह इसे बनाता है और बफर को स्विच करता है, जिसके परिणामस्वरूप एक अवांछित खिड़की अभी भी खुली रहती है।

____________________
| three            | -> winnr = 1                    g:markedWinNum=1
|                  | -> bufnr = 2
|__________________|
| three            | -> winnr = 2
|                  | -> bufnr = 2
|__________________|
| one              | -> winnr = 3                     curNum=3
|                  | -> bufnr = 1                     curBuf=2
|__________________|

0

समान चिह्न-खिड़की-तब-स्वैप-बफर दृष्टिकोण, लेकिन आपको अंतिम स्वैप का पुन: उपयोग भी करने दें।

function! MarkWindowSwap()
    unlet! g:markedWin1
    unlet! g:markedWin2
    let g:markedWin1 = winnr()
endfunction

function! DoWindowSwap()
    if exists('g:markedWin1')
        if !exists('g:markedWin2')
            let g:markedWin2 = winnr()
        endif
        let l:curWin = winnr()
        let l:bufWin1 = winbufnr(g:markedWin1)
        let l:bufWin2 = winbufnr(g:markedWin2)
        exec g:markedWin2 . 'wincmd w'
        exec ':b '.l:bufWin1
        exec g:markedWin1 . 'wincmd w'
        exec ':b '.l:bufWin2
        exec l:curWin . 'wincmd w'
    endif
endfunction

nnoremap ,v :call DoWindowSwap()<CR>
nnoremap ,z :call MarkWindowSwap()<CR>

चूंकि मेरे पास पहले set hiddenसे ही .vimrc है, इसलिए बफ़र्स को मैन्युअल रूप से छिपाने की कोई आवश्यकता नहीं है।
क्यूटीज़ी

-5

आप X-monad जैसे टाइलिंग विंडो मैनेजर का भी उपयोग कर सकते हैं


जबकि यह उत्तर ओपी के प्रश्न से संबंधित नहीं है। एक मैक या विंडोज मशीन पर विम का उपयोग किया जा सकता है। विम टैबलेट और यहां तक ​​कि फोन पर उपलब्ध है, जिनमें से कोई भी आपके विंडो मैनेजर को स्वैप करने की क्षमता नहीं रखता है।
nsfyn55
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.