ग्रहण हॉटकी: टैब्स के बीच स्विच कैसे करें?


672

मैं ग्रहण में खुली खिड़कियों के बीच कैसे स्विच कर सकता हूं? वहाँ Ctrl+ है F6, लेकिन यह मुझसे पूछ रहा है कि मैं कौन सा चाहता हूं, लेकिन मैं इसे सूची से फ़ाइल-चयन के बिना ऑपरेटिंग सिस्टम ( Cmd/ Win+ Tab) में ब्राउज़र या विंडो में टैब की तरह स्विच करना चाहता हूं । ग्रहण में यह आसान काम कैसे करें?

मैंने घटनाओं के लिए हॉटकी असाइन करने की कोशिश की है:

  • आगे
  • आगे का इतिहास
  • अगला पृष्ठ

लेकिन यह मेरे इच्छित तरीके से काम नहीं करता है।


3
मेरे जवाब में ओएस-विशिष्ट शॉर्टकट जोड़े, लेकिन आप उन्हें फिर से परिभाषित नहीं कर सकते।
वॉन

जवाबों:


902
  • CTRL+ E(संपादक की सूची के लिए)
  • CTRL+ F6(एक सूची के माध्यम से अगले संपादक पर स्विच करने के लिए)
    आप 'अगला संपादक' कुंजी के लिए एक और शॉर्टकट असाइन कर सकते हैं।

दो आधिकारिक शॉर्टकट हैं, लेकिन वे दोनों एक सूची प्रदर्शित करते हैं।

CTRL+ Page Up/ CTRL+ Page Downएक सूची प्रदर्शित किए बिना संपादकों के माध्यम से चक्र कर सकते हैं।

शॉर्टकट के अंतिम सेट के साथ क्या दिलचस्प है:
वे परिभाषित किए जाने वाले ग्रहण कुंजी शॉर्टकट में सूचीबद्ध नहीं हैं।
उन्हें बहु संपादक से विरासत में लिया जा सकता है, जिससे उन्हें एक ओएस विशिष्ट शॉर्टकट बनाया जा सकता है


मैक ओएस (OSX) पर शॉर्टकट के बारे में, मैट गेंद को पुन: मैप में सक्षम नहीं होने के लिए सितम्बर 2011 में शिकायत की CTRL+ Page Up/ CTRL+ Page Down:

यह मुझे नट्स को खुले टैब के माध्यम से फ्लिप करने में सक्षम नहीं होने के लिए प्रेरित करता है जैसा कि मैं ओएस एक्स ( - Leftऔर - Right) में हर दूसरे वर्जित कार्यक्रम में कर सकता हूं ।

खैर, मार्च 2012 में, आर्थर ने जवाब दिया:

, मैंने अभी ग्रहण का नवीनतम संस्करण (3.7+) डाउनलोड किया है। मैं "पिछले / अगले टैब" को ( - Leftऔर - Right) संपादक में, जब मुझे यकीन है कि मैं पहले नहीं कर सकता था बांधने में सक्षम था ।
इसलिए मुझे लगता है कि उन्होंने आपको सुना।
यह आपकी अपेक्षा के अनुरूप ही काम करता है, बाएं से दाएं और इसके विपरीत जाने वाला टैब, इतिहास के आधार पर या इस तरह की कुछ बकवास नहीं।

मैट बॉल की पुष्टि:

ओह वाह, "संपादन जावा स्रोत" का चयन वास्तव में काम किया !
अब, दुर्भाग्य से इसका मतलब है कि अगर मैं एक गैर-जावा फ़ाइल (जेएसपी, एक्सएमएल, जेएस, आदि) में नेविगेट करता हूं तो मैं एसओएल हूं।
इसके लिए फिक्स इस जोड़ी के लिए "कॉपी कमांड" है, और सभी "व्हेंस" चुनें जो मुझे चाहिए
अब तक यह जावा और जेएसपी फाइलों के लिए कम से कम खूबसूरती से काम कर रहा है।
यह स्थापित करने के लिए एक प्रमुख PITA है, लेकिन यह केवल एक बार की बात है।

उसकी निर्यातित प्राथमिकताएँ आपके लिए यहाँ उपलब्ध हैं
एक बार आयात होने के बाद, आपको सभी संबंधित प्रकार के दस्तावेज़ देखने चाहिए:

मैक ओएस प्रमुख बाइंडिंग


7
OSX पर, पहले दो कीबोर्ड क्रियाओं के लिए CTRL को CMD से बदलें। लेकिन आपको अभी भी संपादकों के माध्यम से साइकिल चलाने के लिए PgUp या PgDown के साथ CTRL का उपयोग करना होगा। नीचे दिए गए कुछ सुझावों को आज़माते हुए उपयोगी केबी शॉर्टकट का एक और सेट: आप कोड की एक पूरी लाइन को स्थानांतरित करने के लिए ALT + Up या ALT + डाउन का उपयोग कर सकते हैं।
टायलर

5
कोई मौका नहीं है कि अब इंडिगो में रीमैप CTRL+Page Up/ करने का कोई तरीका CTRL+Page Downहै? यह मुझे पागल कर देता है कि मैं खुले टैब के माध्यम से फ्लिप नहीं कर पा रहा हूं क्योंकि मैं ओएस एक्स ( ⌘-Leftऔर ⌘-Right) में हर दूसरे टैबबेड प्रोग्राम में बहुत अधिक कर सकता हूं ।
मैट बॉल

24
एक गैर-विस्तारित OSX कीबोर्ड पर: डिफ़ॉल्ट रूप से fn + ctrl + up_arrow / down_arrow।
बेन फ्लिन

1
@ MДБДLL OS X पर, मैंने अभी ग्रहण का नवीनतम संस्करण डाउनलोड किया है। मैं संपादक में होने पर (tab-Left और Right-Right) को "पिछला / अगला टैब" बांधने में सक्षम हूं, जो मुझे यकीन है कि मैं पहले नहीं कर सका था। इसलिए मुझे लगता है कि उन्होंने आपको सुना। यह आपकी अपेक्षा के अनुरूप ही काम करता है, बाएं से दाएं और इसके विपरीत जाने वाला टैब, इतिहास के आधार पर या इस तरह की कुछ बकवास नहीं।
आर्थर

1
@ MД guessБДLL ouch ... मुझे लगता है कि मुझे यह कहना चाहिए था कि मैं C / C ++ के लिए ग्रहण पर था । क्षमा करें, मेरे मन को पार नहीं किया। क्या यह "एडिटिंग जावा सोर्स" के साथ काम नहीं करता है? अगर यह आपके दर्द को कम कर सकता है, जब मैं दूर दाईं ओर स्थित हूं, won't-राइट मुझे दूर बाएं तक नहीं ले जाएगा ... इसके अलावा, मुझे वास्तव में "गलत त्रुटियां" परेशान कर रही हैं (त्रुटियों को प्रदर्शित किया जाता है लेकिन अद्यतन के बाद से सब कुछ पूरी तरह से संकलित)। आशा है कि आपको वह भी नहीं मिलेगा!
आर्थर

191

यदि आप वरीयताएँ (जैसे विंडो → वरीयताएँ) पर जाते हैं और सामान्य → कुंजी देखें

और फिर "अगला टैब" और "पिछला टैब" खोजें, आप उन्हें हटा सकते हैं।

ग्रहण से पहले, ग्रहण से पहले टैब कमांड


15
मैंने "अगला टैब" -> "Ctrl + Tab" "पिछला टैब" जोड़ा है -> "Ctrl + Shift + Tab" जैसे यह फ़ायरफ़ॉक्स में है
ब्रूनो बीरी

19
यह बिल्कुल सही बात नहीं है। यह सिर्फ टैब के माध्यम से चक्र के क्रम में वे टैब बार पर दिखाई देते हैं। सबसे हाल ही में ऑर्डर करने के लिए स्विच किया गया है।
हफ्थोर

एंड्रॉइड लेआउट संपादक को छोड़कर, महान काम करता है, जो इन आदेशों को अवशोषित / अनदेखा करने के लिए लगता है। यह हमेशा कुछ है!
स्कॉट बिग्स

25
@ हेफ़थोर: मुझे नोटपैड ++ का उपयोग किया जाता है, इसलिए मैं चाहता था कि Ctrl + Tab अंतिम सक्रिय टैब या संपादकों के बीच स्विच हो । ऐसा करने के लिए, "अगला संपादक" से डिफ़ॉल्ट Ctrl + F6 निकालें और "पिछला संपादक" कमांड से Ctrl + Shift + F6 और इसके बजाय उन आदेशों के लिए Ctrl + Tab और Ctrl + Shift + Tab डालें। ध्यान दें कि मुझे किसी कारण से पुरानी आज्ञाओं को हटाना पड़ा (जो मुझे अन्य मामलों में करने की ज़रूरत नहीं थी जहाँ मैंने चाबियाँ बदल दीं), लेकिन खुशी है कि यह अब काम करता है! इसके अलावा, चारों ओर खेलते समय, एक्लिप्स (जूनो) ने अजीब अभिनय किया और मैं किसी भी सामान्य या परिवर्तित कुंजी संयोजनों का उपयोग करके टैब स्विच नहीं कर सका, लेकिन फिर से शुरू किया गया।
फ्रेंड एफएक्स

1
मैंने "अगला टैब" जोड़ा है -> "Ctrl + Tab" "पिछला टैब" -> "Ctrl + Shift + Tab" जैसा कि यह विज़ुअल स्टूडियो में है
Memet Olsen

103

ओएस में विंडोज की तरह स्विच करें ( विंडो पर जाएं जो अंतिम फोकस था )

CTRL-F6 ग्रहण में, जैसे ALT-TAB (खिड़कियों पर), उपलब्ध टैब / खिड़कियों की एक सूची लाती है (यदि आप CTRL/ ALTकुंजी दबाए रखते हैं) और जिस पर आप कूदेंगे जब आप इस कुंजी को जाने देंगे। आपको विंडो का चयन करने की आवश्यकता नहीं है। आप नीचे एक बार पकड़ में कई टैब पार करने के लिए चाहते हैं, तो CTRLबटन और नल TABबटन। यह विंडोज पर ALT- केTAB समान व्यवहार है ।

इस अर्थ में, CTRL- SHIFT-F6 ग्रहण में ALT- SHIFT- -TAB एनालॉग है। व्यक्तिगत रूप से, मैं ग्रहण में इन बाइंडिंग को विज़ुअल स्टूडियो की तरह बदलता हूं। यानी CTRL-TAB और CTRL- SHIFT-TAB और मैं इसे इस तरह करते हैं:

विंडो> प्राथमिकताएं> सामान्य> कुंजी

फिर "अगला संपादक" = Ctrl+Tab और "पिछला संपादक" = Ctrl+ Shift+ सेट करेंTab । नया बंधन सेट करने से पहले "Unbind Command" पर क्लिक करना न भूलें।

ब्राउज़र की तरह स्विच करें ( वर्तमान टैब के दाईं ओर टैब पर जाएं )

यह है CTRL-PageDown दाएं जाना, CTRL-PageUp बाएं जाना। निराशा की बात यह है कि जब आप टैब की सूची के अंत में पहुंच जाते हैं (तब राइट हैंड टैब कहते हैं) और फिर दाईं ओर फिर से जाने का प्रयास करें। ग्रहण पहले टैब (सबसे बाईं ओर) की तरह गोल नहीं होता है जैसे अधिकांश ब्राउज़र होते हैं।


12
यह इस धागे में सबसे कम-रेटेड उत्तर है। विशेष रूप से जूनो के बाद से जो टैब एक शुद्ध सूची में दिखाए जाते हैं और हाल ही में उपयोग किए गए संपादकों के नहीं।
जेसन एक्सेलसन

यह 90% समय काम करता है। यदि आपका माउस कर्सर तब होता है जब टैब की सूची पॉप अप होती है, तो यह विफल हो जाता है। कर्सर के सामने जो भी अशुभ टैब पॉप अप होता है वह चयनित हो जाता है।
उपयोगकर्ता

ग्रहण संस्करण 3.6.2 उस समय का 100% काम करता है, जहाँ भी माउस है। यह सब के बाद, ग्रहण की प्राकृतिक व्यवहार अलग-अलग कुंजी को फिर से मैप किया गया है! हालांकि प्राचीन ग्रहण संस्करणों की कोशिश नहीं की गई है ...
रॉबिनो

1
आपको "अगला संपादक" कमांड को खोलना नहीं है। बस "कॉपी कमांड" पर क्लिक करें और कॉपी को संपादित करें और इसे बाइंड करें CTRL-TAB
जिलफिश

1
Unbind अनुस्मारक कुंजी है। 2019-03 के ग्रहण में, यह तब तक काम नहीं करता था जब तक कि मूल कमांड को हटा नहीं दिया गया था, ऐसा लगता है कि यह अब कई बाइंडिंग का समर्थन नहीं करता है।
लियाम स्टील

55

आप अपने पिछले टैब पर जाने के लिए + या, आगे जाने के लिए ALT+ Leftका उपयोग कर सकते हैं। यह विधि इतिहास की तरह टैब-स्विचिंग का उपयोग कर रही है, हालांकि, इसलिए यह आपके द्वारा खोले गए पिछले टैब पर जाएगी, और यदि आप एक बार या उससे अधिक "वापस" चले गए हैं, तो इसे अग्रेषित करें। थोड़ा अजीब है, मुझे पता है, लेकिन यह काम करता है। आप हर टैब पर एक बार क्लिक करके इतिहास को हमेशा "रीसेट" कर सकते हैं।ALTRight


5
इतिहास में दर्ज की गई कार्रवाइयों जैसे कि एक ही कक्षा में विधि की परिभाषा में जाने पर उपयोगी नहीं।
SiN

यह उपयोगी होने के लिए उपयोग किया जाता है, इस
हेलिओस के

2
मैं वास्तव में उस व्यवहार को पसंद करता हूं जहां यह विधि परिभाषा में जाने जैसी क्रियाओं के लिए जाता है, यह बहुत सारी फाइलों को नेविगेट करते समय आगे और पीछे जाने का एक उपयोगी तरीका है।
इब्राहिम

1
यह बहुत काम करता है जब संपादन खिड़कियों के बीच आगे और पीछे साइकिल चलाना। मैं अपनी स्क्रीन को 2 में विभाजित करना पसंद करता हूं और अन्य विधियां केवल 1 टैब ग्रुपिंग को चक्रित करती हैं, (ctrl-F6 को छोड़कर, लेकिन मुझे वह बोझिल लगता है)।
जलेंगे


13

CTRL+ F6उपयोग करने के लिए अच्छा है। यदि आप अगले / पिछले टैब पर जाना चाहते हैं, तो आपको CTRL+ Page Down/ CTRL+ करना होगा Page Up


2
हां, मैं अक्सर इसका इस्तेमाल करता हूं। हालाँकि, जब संपादक कई बार विचार प्रस्तुत करता है (उदाहरण के लिए जब आप किसी फ़ाइल XMLया propertiesफ़ाइल पर काम करते हैं ), तो वह अलग-अलग विचारों के बीच स्विच करता है, और आप अब टैब के बीच स्विच नहीं कर पा रहे हैं :(
रोमेन लिंसोलस

"CTRL + F6 का उपयोग करना अच्छा है।" यहाँ कुछ भी नहीं है, विंडोज में ग्रहण फोटॉन पर।
क्रिसजेजे

10

डिफ़ॉल्ट Ctrl+ है F6। आप इसे विंडो वरीयताओं पर जाकर बदल सकते हैं । मैं आमतौर पर इसे Ctrl+ में बदल देता हूं Tab, वही हम एक ब्राउज़र और अन्य सामान में स्विचिंग टैब में उपयोग करते हैं।


मैं एक डाउन-वोटर नहीं हूं, लेकिन मैं ग्रहण इंडिगो का उपयोग करके विंडोज विस्टा पर एक साथ Ctrl + टैब के साथ एक महत्वपूर्ण बंधन को मैप करने की आपकी क्षमता पर सवाल उठाता हूं। यह असंभव है! अगर मैं टैब को दबाता, तो यह बटन और ड्रॉप-डाउन सूची पर ध्यान केंद्रित करता।
tom_mai78101

@ tom_mai78101 क्षमा करें, मुझे Windows Vista के साथ इस मुद्दे की जानकारी नहीं है। आप अपनी पसंद की एक अलग मैपिंग आज़मा सकते हैं, हालाँकि यह XP में सफल है।
asgs

6

कस्टम कीबाइंडिंग अनुक्रम उदाहरण: CTRL + TAB ग्रहणशील आरसीपी का उपयोग करके चिपचिपा मॉड्यूल या संपादकों के आगे की दिशा के बीच स्विच करना ।

आप CTRL + TAB RCP ग्रहण का उपयोग करके किसी अन्य संपादक को खोलने और पिछले संपादक को बंद करने के लिए दूसरी बार दबाते हैं ।

package rcp_demo.Toolbar;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.handlers.HandlerUtil;
import rcp_demo.Editor.EmployeeEditor;
import rcp_demo.Editor.EmployeeEditorInput;
import rcp_demo.Editor.ProductEditor;
import rcp_demo.Editor.ProductEditorInput;
import rcp_demo.Editor.UserEditor;
import rcp_demo.Editor.UserEditorInput;

public class Forward_Editor extends AbstractHandler{

    static String Editor_name;  //  Active Editor name store in Temporary 
    static int cnt;             //  close editor count this variable
    @Override
    public Object execute(ExecutionEvent event) throws ExecutionException {

        IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
        IWorkbenchPage page = window.getActivePage();

        UserEditorInput std_input = new UserEditorInput();
        EmployeeEditorInput emp_input=new EmployeeEditorInput();
        ProductEditorInput product_input=new ProductEditorInput();

        IEditorReference[] editors = page.getEditorReferences();

        //Blank Editor Window to execute..
        if(editors.length==0)
        {
            //First time close editor can open Student_Editor
            if(cnt==1 && Editor_name.equals("Student_Editor"))
            {
                try {
                    page.openEditor(emp_input, EmployeeEditor.Id);
                    cnt=1;
                    Editor_name=page.getActiveEditor().getTitle();
                    System.out.println("EMP>>Len:: "+editors.length+"..EDi::"+Editor_name);
                } catch (PartInitException e) {
                    e.printStackTrace();
                }       
            }
            //First time close editor can open Employee_Editor
            else if(cnt==1 && Editor_name.equals("Employee_Editor"))
            {
                try {
                    page.openEditor(product_input,ProductEditor.ID);
                    cnt=1;
                    Editor_name=page.getActiveEditor().getTitle();
                    System.out.println("PRO>>Len:: "+editors.length+"..EDi::"+Editor_name); 
                } catch (PartInitException e) {e.printStackTrace();
                }
            }
            //First time close editor can open Product_Editor
            else if(cnt==1 && Editor_name.equals("Product_Editor"))
            {
                try {
                    page.openEditor(std_input, UserEditor.ID);
                    System.out.println("student Editor open");
                    cnt=1;
                    Editor_name=page.getActiveEditor().getTitle();
                    System.out.println("Close::"+Editor_name);
                } catch (PartInitException e) {
                    e.printStackTrace();
                }
            }
            //First Time call // empty editors 
            else{
                try {
                    page.openEditor(std_input, UserEditor.ID);
                    System.out.println("student Editor open");
                    Editor_name=page.getActiveEditor().getTitle();
                } catch (PartInitException e) {
                    e.printStackTrace();
                }
            }
        }//End if condition

        //AvtiveEditor(Student_Editor) close to open Employee Editor
        else if(page.getActiveEditor().getTitle().equals("Student_Editor"))
        {
            try {
                //page.closeAllEditors(true);
                page.closeEditor(page.getActiveEditor(), true);
                page.openEditor(emp_input, EmployeeEditor.Id);
                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("EMP>>Len:: "+editors.length+"..EDi::"+Editor_name);
            } catch (PartInitException e) {
                e.printStackTrace();
            }
        }
        //AvtiveEditor(Employee_Editor) close to open Product Editor
        else if(page.getActiveEditor().getTitle().equals("Employee_Editor"))
        {
            try {
                page.closeAllEditors(true);
                page.openEditor(product_input,ProductEditor.ID);

                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("PRO>>Len:: "+editors.length+"..EDi::"+Editor_name);

            } catch (PartInitException e) {
                e.printStackTrace();
            }
        }
        //AvtiveEditor(Product_Editor) close to open Student Editor
        else if(page.getActiveEditor().getTitle().equals("Product_Editor"))
        {
            try {
                page.closeAllEditors(true);
                page.openEditor(std_input, UserEditor.ID);
                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("stud>>Len:: "+editors.length+"..EDi::"+Editor_name);
            } catch (PartInitException e) {
                e.printStackTrace();
            }
        }
        //by default open Student Editor
        else 
        {
            try {
                page.closeAllEditors(true);
                page.openEditor(std_input, UserEditor.ID);
                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("stud_else>>Len:: "+editors.length+"..EDi::"+Editor_name);
            } catch (PartInitException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

>Custom KeyBinding sequence example : <kbd> SHIFT + TAB </kbd> to switch between visilble Modules or Editors **Backword** direction using Eclipse RCP.


package rcp_demo.Toolbar;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.handlers.HandlerUtil;
import rcp_demo.Editor.EmployeeEditor;
import rcp_demo.Editor.EmployeeEditorInput;
import rcp_demo.Editor.ProductEditor;
import rcp_demo.Editor.ProductEditorInput;
import rcp_demo.Editor.UserEditor;
import rcp_demo.Editor.UserEditorInput;

public class Backword_Editor extends AbstractHandler{

    static String Editor_name;   // Active Editor name store in Temporary 
    static int cnt;

    @Override
    public Object execute(ExecutionEvent event) throws ExecutionException {

        IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
        IWorkbenchPage page = window.getActivePage();
        //Three object create in EditorInput 
        UserEditorInput std_input = new UserEditorInput();
        EmployeeEditorInput emp_input=new EmployeeEditorInput();
        ProductEditorInput product_input=new ProductEditorInput();

        IEditorReference[] editors = page.getEditorReferences();
        System.out.println("Length : "+editors.length);

        if(editors.length==0)
        {
            //First time close editor can open Student_Editor
            if(cnt==1 && Editor_name.equals("Product_Editor"))
            {
                try {
                    page.openEditor(emp_input, EmployeeEditor.Id);
                    cnt=1;
                    Editor_name=page.getActiveEditor().getTitle();
                    System.out.println("EMP>>Len:: "+editors.length+"..EDi::"+Editor_name);
                } catch (PartInitException e) {
                    e.printStackTrace();
                }               
            }
            //First time close editor can open Employee_Editor
            else if(cnt==1 && Editor_name.equals("Employee_Editor"))
            {
                try {
                    page.openEditor(std_input, UserEditor.ID);
                    cnt=1;
                    Editor_name=page.getActiveEditor().getTitle();
                    System.out.println("Student>>Len:: "+editors.length+"..student::"+Editor_name);

                } catch (PartInitException e) {
                    e.printStackTrace();
                }
            }
            //First time close editor can open Product_Editor
            else if(cnt==1 && Editor_name.equals("Student_Editor"))
            {
                        try {
                            page.openEditor(product_input,ProductEditor.ID);
                            cnt=1;
                            Editor_name=page.getActiveEditor().getTitle();
                            System.out.println("PRO>>Len:: "+editors.length+"..EDi::"+Editor_name);

                        } catch (PartInitException e) {
                            e.printStackTrace();
                        }
            } 
            //First Time or empty editors to check this condition
            else{
                try {
                    page.openEditor(product_input,ProductEditor.ID);
                    System.out.println("product Editor open");
                } catch (PartInitException e) {
                    e.printStackTrace();
                }
            }
        }
        //AvtiveEditor(Product_Editor) close to open Employee Editor
        else if(page.getActiveEditor().getTitle().equals("Product_Editor"))
        {
            System.out.println("Product:: "+page.getActiveEditor().getTitle());
            try {
                page.closeAllEditors(true);
                page.openEditor(emp_input, EmployeeEditor.Id);
                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("Employee Editor open");
            } catch (PartInitException e) {
                e.printStackTrace();
            }
        }
        //AvtiveEditor(Employee_Editor) close to open Student Editor
        else if(page.getActiveEditor().getTitle().equals("Employee_Editor"))
        {
            System.out.println("Emp:: "+page.getActiveEditor().getTitle());
            try {
                page.closeAllEditors(true);
                page.openEditor(std_input, UserEditor.ID);
                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("student Editor open");
            } catch (PartInitException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        //AvtiveEditor(Student_Editor) close to open Product Editor
        else if(page.getActiveEditor().getTitle().equals("Student_Editor"))
        {
            System.out.println("Product:: "+page.getActiveEditor().getTitle());
            try {
                page.closeAllEditors(true);
                page.openEditor(product_input,ProductEditor.ID);
                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("product Editor open");
            } catch (PartInitException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        //by default open Student Editor
        else 
        {
            try {
                page.closeAllEditors(true);
                page.openEditor(product_input,ProductEditor.ID);
                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("product Editor open");
            } catch (PartInitException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return null;
    }
}

कस्टम कीबाइंडिंग अनुक्रम उदाहरण: ग्रहण आरसीपी का उपयोग करते हुए SHIFT + TAB चिपचिपा मॉड्यूल या संपादकों के पीछे की दिशा के बीच स्विच करना ।

package rcp_demo.Toolbar;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.handlers.HandlerUtil;
import rcp_demo.Editor.EmployeeEditor;
import rcp_demo.Editor.EmployeeEditorInput;
import rcp_demo.Editor.ProductEditor;
import rcp_demo.Editor.ProductEditorInput;
import rcp_demo.Editor.UserEditor;
import rcp_demo.Editor.UserEditorInput;

public class Backword_Editor extends AbstractHandler{

    static String Editor_name;   // Active Editor name store in Temporary 
    static int cnt;

    @Override
    public Object execute(ExecutionEvent event) throws ExecutionException {

        IWorkbenchWindow window = HandlerUtil.getActiveWorkbenchWindow(event);
        IWorkbenchPage page = window.getActivePage();
        //Three object create in EditorInput 
        UserEditorInput std_input = new UserEditorInput();
        EmployeeEditorInput emp_input=new EmployeeEditorInput();
        ProductEditorInput product_input=new ProductEditorInput();

        IEditorReference[] editors = page.getEditorReferences();
        System.out.println("Length : "+editors.length);

        if(editors.length==0)
        {
            //First time close editor can open Student_Editor
            if(cnt==1 && Editor_name.equals("Product_Editor"))
            {
                try {
                    page.openEditor(emp_input, EmployeeEditor.Id);
                    cnt=1;
                    Editor_name=page.getActiveEditor().getTitle();
                    System.out.println("EMP>>Len:: "+editors.length+"..EDi::"+Editor_name);
                } catch (PartInitException e) {
                    e.printStackTrace();
                }               
            }
            //First time close editor can open Employee_Editor
            else if(cnt==1 && Editor_name.equals("Employee_Editor"))
            {
                try {
                    page.openEditor(std_input, UserEditor.ID);
                    cnt=1;
                    Editor_name=page.getActiveEditor().getTitle();
                    System.out.println("Student>>Len:: "+editors.length+"..student::"+Editor_name);

                } catch (PartInitException e) {
                    e.printStackTrace();
                }
            }
            //First time close editor can open Product_Editor
            else if(cnt==1 && Editor_name.equals("Student_Editor"))
            {
                        try {
                            page.openEditor(product_input,ProductEditor.ID);
                            cnt=1;
                            Editor_name=page.getActiveEditor().getTitle();
                            System.out.println("PRO>>Len:: "+editors.length+"..EDi::"+Editor_name);

                        } catch (PartInitException e) {
                            e.printStackTrace();
                        }
            } 
            //First Time or empty editors to check this condition
            else{
                try {
                    page.openEditor(product_input,ProductEditor.ID);
                    System.out.println("product Editor open");
                } catch (PartInitException e) {
                    e.printStackTrace();
                }
            }
        }
        //AvtiveEditor(Product_Editor) close to open Employee Editor
        else if(page.getActiveEditor().getTitle().equals("Product_Editor"))
        {
            System.out.println("Product:: "+page.getActiveEditor().getTitle());
            try {
                page.closeAllEditors(true);
                page.openEditor(emp_input, EmployeeEditor.Id);
                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("Employee Editor open");
            } catch (PartInitException e) {
                e.printStackTrace();
            }
        }
        //AvtiveEditor(Employee_Editor) close to open Student Editor
        else if(page.getActiveEditor().getTitle().equals("Employee_Editor"))
        {
            System.out.println("Emp:: "+page.getActiveEditor().getTitle());
            try {
                page.closeAllEditors(true);
                page.openEditor(std_input, UserEditor.ID);
                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("student Editor open");
            } catch (PartInitException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        //AvtiveEditor(Student_Editor) close to open Product Editor
        else if(page.getActiveEditor().getTitle().equals("Student_Editor"))
        {
            System.out.println("Product:: "+page.getActiveEditor().getTitle());
            try {
                page.closeAllEditors(true);
                page.openEditor(product_input,ProductEditor.ID);
                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("product Editor open");
            } catch (PartInitException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        //by default open Student Editor
        else 
        {
            try {
                page.closeAllEditors(true);
                page.openEditor(product_input,ProductEditor.ID);
                cnt=1;
                Editor_name=page.getActiveEditor().getTitle();
                System.out.println("product Editor open");
            } catch (PartInitException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
        return null;
    }
}

कुंजी अनुक्रम

एम 1 का मतलब है CTRL

एम 2 का अर्थ है SHIFT

plugin.xml


<extension point="org.eclipse.ui.commands">
        <command
                defaultHandler="rcp_demo.Toolbar.Forward_Editor"
                id="RCP_Demo.Toolbar.Forward_editor_open_cmd"
                name="Forward_Editor">
        </command>
        <command
                defaultHandler="rcp_demo.Toolbar.Backword_Editor"
                id="RCP_Demo.Toolbar.backwards_editor_open_cmd"
                name="Backword_Editor">
        </command>
    </extension>
<extension point="org.eclipse.ui.bindings">
        <key
                commandId="RCP_Demo.Toolbar.Forward_editor_open_cmd"
                schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
                sequence="M1+TAB">
        </key>  
        <key
                commandId="RCP_Demo.Toolbar.backwards_editor_open_cmd"
                schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"
                sequence="M2+TAB">
        </key>              
</extension>

5

3 पंक्ति AutoHotKey स्क्रिप्ट (विंडोज पर, वैसे भी):

#IfWinActive ahk_class SWT_Window0
^+Tab::^PgUp
^Tab::^PgDn

इसे अपने स्टार्टअप फ़ोल्डर में रखें (इसे * .ahk के रूप में सहेजें, AutoHotKey इंस्टॉल होना चाहिए) और ग्रहण टैब अब क्रोम या फ़ायरफ़ॉक्स की तरह काम करेंगे।


3

हल किया!!

Microsoft Visual Studio में स्कीम बदलें

विंडो> प्राथमिकताएं> सामान्य> कुंजी

ड्रॉपडाउन योजनाओं के लिए देखें

मेरा ग्रहण संस्करण:

वेब डेवलपर्स के लिए ग्रहण ईई आईडीई।

संस्करण: जूनो सेवा रिलीज़ 1 बिल्ड आईडी: 20120920-0800


3

कोई भी कभी भी मेरे उत्तर को नहीं पढ़ेगा, लेकिन फिर भी ... यदि आप मैक ओएस एक्स पर हैं तो आप ग्रहण में इतिहास नेविगेशन के लिए मल्टी टच जेस्चर को पसंद करेंगे: http://sourceforge.net/apps/mediawiki/eclipsemultitch/


1
मैं हर एक दिन सभी प्रविष्टियाँ पढ़ता हूं ;) और "एक्लिप्स मल्टी-टच" अच्छा लगता है, इसलिए +1। लेकिन यह 2010 से निष्क्रिय लग रहा है। क्या यह अभी भी जूनो जैसे हालिया ग्रहण 4.x के साथ काम करेगा?
VonC

2

खिड़कियों पर यदि आप एक 5 बटन माउस है, तो आप के एवज में आगे और पीछे का उपयोग कर सकते ALT+Leftहैं और ALT+Right


2

पिछले टैब पर वापस जाने के लिए शॉर्टकट कुंजी

Alt+ LeftArrowवापस जाने के लिए।


1

ऐसा करने का एक तरीका VI प्लगिन का उपयोग करना है , और फिर आप फ़ाइलों के बीच जाने के लिए बस n: (और: N) करते हैं।

यही तो मैं करता हूं।


1

आप प्राथमिकताएं संवाद के शीर्ष पर फ़िल्टर फ़ील्ड में वरीयताएँ -> सामान्य -> ​​कुंजी (या सिर्फ "कुंजियाँ" टाइप कर सकते हैं) सेट कर सकते हैं।

एक बार कीज़ सेक्शन चुने जाने के बाद, नेक्स्ट टैब और पिछला टैब ढूंढें और "बाइंडिंग" फ़ील्ड में क्लिक करके और फिर अपनी हॉटकी टाइप करके अपनी हॉटकी असाइन करें।

प्रक्रिया को पूरा करने के लिए लागू करें या ठीक पर हिट करें।


1

मैं VonC प्रतिक्रिया, कुछ जोड़कर बोली।

  • Ctrl+ PgUp( PgDn) वर्तमान स्टैक में टैब के बीच स्विच करने के लिए (संपादक और दृश्य दोनों)
  • Ctrl+ Eफ़िल्टर्ड सूची का उपयोग करके, वर्तमान स्टैक में टैब के बीच स्विच करने के लिए
  • Ctrl+ F6संपादकों के बीच स्विच करने के लिए, कोई फर्क नहीं पड़ता जो स्टैक
  • Ctrl+ F7विचारों के बीच स्विच करने के लिए, कोई फर्क नहीं पड़ता जो ढेर

इसके अलावा, + ( ) के बजाय स्विचिंग टैब के लिए + का उपयोग करने का अनुरोध करने के लिए बग 206299 खुला है ।CtrlTabCtrlPgUpPgDn

  • चूंकि यह पहुंच को तोड़ देगा, इसलिए उपयोगकर्ता को इसके लिए प्राथमिकता तय करनी चाहिए। शायद ओम्फ इंस्टॉल के दौरान वेलकम प्रश्नावली में एक सवाल होना चाहिए।

यदि संतुष्ट नहीं हैं, तो आप विंडो> प्राथमिकताएं> सामान्य> कुंजी से अपने आप को कुंजी बंधन प्रदान कर सकते हैं ।


1

किसी कारण से मेरी ग्रहण सेटिंग दूषित हो गई थी, इसलिए मुझे फ़ाइल को मैन्युअल रूप से संपादित करना पड़ा / .plugins/org.eclipse.e4.workbench/workbench.xmi

मुझे पहले से ब्राउज़र-जैसे टैब स्विचिंग के लिए सेट Ctrl+ होना चाहिए Tab, और यहां तक ​​कि ग्रहण की प्राथमिकताओं में सभी प्रमुख बाइंडिंग को रीसेट करने से शॉर्टकट से छुटकारा नहीं मिलेगा (वे कहीं भी प्रदर्शित नहीं किए गए थे)। मैंने उपर्युक्त फ़ाइल को खोला और गैर-कामकाजी शॉर्टकट से संबंधित <bindings>तत्वों को हटा दिया <tags>type:user</tags>


1

बाएं से दाएं: ctrl+ shift+ 9 या ctrl+ shift+ Page Upया ctrl+Page Up

बाएं से दाएं: ctrl+ shift+ 3या ctrl+ shift+ Page Downया ctrl+Page Down


0

यदि आप बस अपने वर्तमान और अपने पिछले टैब चयनों के बीच स्विच करना चाहते हैं, तो CTRL+ का उपयोग करके F6आपको आगे और पीछे स्विच किया जाएगा। अपने इतिहास में और टैब पर नेविगेट करने के लिए, आपको संपादकों की विंडो खुली रहने पर UP/ DOWNकुंजियों का उपयोग करने की आवश्यकता है। यह हेलिओस (ग्रहण 3.6) के साथ काम करता है; यकीन नहीं होता कि यह ग्रहण के पुराने संस्करणों के लिए सच है।


0

जब तक आप चाहते हैं संपादक तक पहुँचें, तब तक दबाए रखें CTRLऔर F6छोड़ दें। यूआई खिड़की के चयन के रूप में सुंदर नहीं है, लेकिन कार्यक्षमता समान है।


0

SLES12 मशीन पर आप डिफ़ॉल्ट रूप से टैब के बीच नेविगेट करने के लिए Ctrl+ PageUpऔर Ctrl+ PageDownका उपयोग कर सकते हैं । आप इन कुंजियों को हमेशा "सामान्य" श्रेणी के अंतर्गत "कुंजियाँ" अनुभाग के माध्यम से ब्राउज़ करके प्राथमिकताएँ विंडो से बदल सकते हैं। इस प्रक्रिया को ऊपर विक्टर और VonC द्वारा अच्छी तरह से समझाया गया है।


0

मैं ग्रहण में खुली खिड़कियों के बीच कैसे स्विच कर सकता हूं

CTRL + F7 यहां काम करता है - विंडोज पर ग्रहण फोटॉन।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.