Eclipse HotKey : 탭 간을 전환하는 방법?

Eclipse에서 열린 창 사이를 전환하는 방법은 무엇입니까? 이 Ctrl+는 F6하지만, 내가 원하는 어느 쪽이 나 한테 물어,하지만 내가 원하는 운영 체제 (의 브라우저 또는 창에서 탭처럼 스위치 Cmd/ Win+ Tab목록에서 파일을 선택하지 않고). 이클립스 에서이 쉬운 일을하는 방법?

이벤트에 핫키를 할당하려고했습니다.

• 앞으로
• 미래 역사
• 다음 페이지

그러나 그것은 내가 원하는 방식으로 작동하지 않습니다.

• CTRL+ E(편집기 목록 용)
• CTRL+ F6(목록을 통해 다음 편집기로 전환)
  '다음 편집기'키에 다른 바로 가기를 지정할 수 있습니다.

두 개의 공식 단축키이지만 둘 다 목록이 표시됩니다.

CTRL+ Page Up/ CTRL+ Page Down는 목록을 표시하지 않고 편집기를 순환 할 수 있습니다.

마지막 단축키 세트에서 흥미로운 점은
정의 할 Eclipse 키 단축키에 나열되지 않은 것입니다.
멀티 페이지 편집기에서 상속되어 OS 별 바로 가기 가 될 수 있습니다 .

Mac OS (OSX)의 바로 가기와 관련하여 Matt Ball 은 2011 년 9 월에 CTRL+ Page Up/ CTRL+ 를 다시 매핑 할 수 없다고 불평했습니다 Page Down.

OS X ( ⌘- Left및 ⌘- Right)의 다른 모든 탭 프로그램에서 할 수있는 것처럼 열린 탭을 넘길 수 없도록 견과류를 운전합니다 .

글쎄, 2012 년 3 월 Arthur 는 다음과 같이 대답했습니다.

방금 최신 버전의 Eclipse (3.7+)를 다운로드했습니다. 나는에 "이전 / 다음 탭을"결합 할 수있었습니다 ( ⌘- Left및 ⌘- Right때 나는 확신 내가 전에 할 수 없었던거야 편집기에서).
그들이 당신을들은 것 같아
그것은 역사 기반이나 그런 말이 아닌 탭에서 왼쪽에서 오른쪽으로 또는 그 반대로 탭이 예상대로 작동합니다.

매트 볼 은 다음을 확인합니다.

와우, "Java 소스 편집"을 선택하면 실제로 작동했습니다 !
불행히도 이것은 Java 이외의 파일 (JSP, XML, JS 등)로 탐색하면 SOL입니다.
이 문제에 대한 해결책은이 쌍의 "명령 복사"를 수행하고 원하는 "whens"를 모두 선택하는 것 입니다.
지금까지는 적어도 Java 및 JSP 파일에서 아름답게 작동합니다.
이것은 설정해야 할 주요 PITA이지만 한 번만 수행하면됩니다.

그의 수출 환경 설정은 여기 에서 사용할 수 있습니다 .
일단 가져 오면 모든 관련 문서 유형에 대해 다음을 볼 수 있습니다.

환경 설정 (예 : 창 → 환경 설정)으로 이동하여 일반 → 키를 보는 경우

"Next Tab"과 "Previous Tab"을 검색하면 다시 매핑 할 수 있습니다.

OS에서 Windows처럼 전환 ( 마지막으로 초점을 맞춘 창으로 이동 )

CTRL-F6 같은 이클립스, ALT-TAB (Windows의 경우), 탭의 목록이 표시 / 사용 가능 창 (당신은 유지하는 경우 CTRL/의 ALT하이라이트 당신이 키의 가자 때 이동합니다 하나의 우울 키). 창을 선택할 필요는 없습니다. 한 번에 여러 탭을 탐색하려면 CTRL버튼을 누른 상태에서 TAB버튼을 누릅니다. 이것은 동일한 동작입니다 ALT-TAB Windows에서합니다.

이런 의미에서 CTRL- SHIFT-F6 일식에서입니다 ALT- SHIFT-TAB 아날로그. 개인적으로 Eclipse에서 이러한 바인딩을 Visual Studio와 같이 변경합니다. 즉 CTRL-TAB 및 CTRL- SHIFT-TAB 나는 이런 식으로 작업을 수행합니다

창> 환경 설정> 일반> 키

그런 다음 "Next Editor"= Ctrl+Tab 및 "Previous Editor"= Ctrl+ Shift+를 설정하십시오Tab . 새 바인딩을 설정하기 전에 "바인드 해제 명령"을 클릭하는 것을 잊지 마십시오.

브라우저처럼 전환 ( 현재 탭의 오른쪽에있는 탭으로 이동 )

이다 CTRL-PageDown 바로 이동 CTRL-PageUp 왼쪽으로 이동합니다. 실망스럽게도 탭 목록 (맨 오른쪽 탭)의 끝 부분에 도달 한 다음 다시 오른쪽으로 가려고하면 Eclipse는 대부분의 브라우저와 마찬가지로 첫 번째 탭 (맨 왼쪽)으로 순환하지 않습니다.

ALT+ Left를 사용 하여 이전 탭 으로 이동 하거나 ALT+ Right를 사용하여 앞으로 이동할 수 있습니다. 이 방법은 기록과 같은 탭 전환을 사용하므로 이전에 열었던 탭으로 이동하여 한 번 이상 "뒤로"이동 한 경우 앞으로 이동합니다. 좀 이상하지만 알아요. 모든 탭을 한 번 클릭하여 언제든지 기록을 "재설정"할 수 있습니다.

• Right측면 이동 : Ctrl+page Down
• Left측면 이동 : CTRL+page Up

추가

• 열린 탭 목록 가져 오기 : Ctrl+F6

이클립스 기타 바로 가기

• 링크 : http://www.shortcutworld.com/en/win/Eclipse.html
• PDF : http://eclipse-tools.sourceforge.net/Keyboard_shortcuts_%283.0%29.pdf

CTRL+ F6사용하기 좋습니다. 다음 / 이전 탭으로 전환하려면 CTRL+ Page Down/ CTRL+ 를 수행해야합니다 Page Up.

기본값은 Ctrl+ F6입니다. 창 환경 설정 으로 이동하여 변경할 수 있습니다 . 나는 보통 브라우저와 다른 것들에서 탭을 전환 할 때 사용하는 것과 같은 Ctrl+로 변경합니다 Tab.

사용자 키 바인딩 시퀀스 예 : CTRL + TAB visilble 모듈 또는 편집자 전환 할 앞으로 이클립스 RCP를 이용 방향.

CTRL + TAB 두 번째 를 누르면 다른 편집기가 열리고 RCP Eclipse를 사용하여 이전 편집기가 닫힙니다.

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 visilble 모듈 또는 편집자 전환 할 되돌아 가기를 이클립스 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;
    }
}

키 순서

M1은 CTRL

M2는 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>

3 줄 AutoHotKey 스크립트 (Windows의 경우) :

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

이것을 시작 폴더에 넣으십시오 (* .ahk로 저장하고 AutoHotKey가 설치되어 있어야 함) 이제 Eclipse 탭은 Chrome 또는 Firefox처럼 작동합니다.

해결 !!

구성표를 Microsoft Visual Studio로 변경

창> 환경 설정> 일반> 키

구성표 검색 드롭 다운

내 이클립스 버전 :

웹 개발자를위한 Eclipse Java EE IDE.

버전 : Juno 서비스 릴리스 1 빌드 ID : 20120920-0800

아무도 내 대답을 읽지 못하지만 어쨌든 ... Mac OS X 인 경우 Eclipse의 히스토리 탐색을위한 멀티 터치 제스처를 좋아할 것입니다 : http://sourceforge.net/apps/mediawiki/eclipsemultitch/

당신이 5 버튼 마우스가있는 경우 창에, 당신은 대신에 앞으로 다시 사용할 수 있습니다 ALT+Left및 ALT+Right.

이전 탭으로 돌아가는 바로 가기 키

Alt+ LeftArrow돌아 가기

이를 수행하는 한 가지 방법은 VI 플러그인 을 사용하는 것입니다. 그런 다음 : n (및 : N)을 사용하여 파일 사이를 이동합니다.

그게 내가하는 일입니다.

환경 설정-> 일반-> 키에서 단축키를 설정하거나 환경 설정 대화 상자의 상단에있는 필터 필드에 "키"를 입력하면됩니다.

키 섹션이 선택되면 다음 탭 및 이전 탭을 찾아 "바인딩"필드를 클릭 한 다음 핫키를 입력하여 고유 한 핫키를 할당하십시오.

적용 또는 확인을 눌러 프로세스를 완료하십시오.

VonC 응답을 인용하여 무언가를 추가합니다.

• Ctrl+ PgUp( PgDn) 현재 스택에서 탭 간 전환 (편집기 및보기 모두)
• Ctrl+ E필터링 된 목록을 사용하여 현재 스택의 탭 간 전환
• Ctrl+ F6어떤 스택에 상관없이 편집기 간 전환
• Ctrl+ F7어떤 스택에 상관없이보기 간 전환

또한 + ( ) 대신 탭 전환을 위해 + 를 사용하도록 요청하기 위해 버그 206299가 열려 있습니다.CtrlTabCtrlPgUpPgDn

• 접근성이 깨질 수 있으므로 사용자는 이에 대한 기본 설정을 지정해야합니다. 아마도 Oomph 설치 중에 Welcome Questionnaire에 질문이있을 것입니다.

만족스럽지 않은 경우 창> 환경 설정> 일반> 키 에서 키 바인딩을 직접 지정할 수 있습니다 .

어떤 이유로 내 Eclipse 설정이 손상되어 /.plugins/org.eclipse.e4.workbench/workbench.xmi 파일을 수동으로 편집해야 했습니다.

이전에 Ctrl+ Tab를 브라우저와 같은 탭 전환으로 설정해야 했으며 Eclipse 환경 설정의 모든 키 바인딩을 재설정해도 단축키가 제거되지 않습니다 (어디에도 표시되지 않음). 위에서 언급 한 파일을 열고 작동하지 않는 바로 가기 <bindings>와 <tags>type:user</tags>관련된 요소를 제거했습니다 .

오른쪽에서 왼쪽으로 : ctrl+ shift+ 9 또는 ctrl+ shift+ Page Up또는 ctrl+Page Up

왼쪽에서 오른쪽으로 : ctrl+ shift+ 3또는 ctrl+ shift+ Page Down또는 ctrl+Page Down

현재 탭과 이전 탭을 간단히 전환하려면 CTRL+ F6를 사용하여 앞뒤로 전환합니다. 히스토리에서 다시 탭으로 이동하려면 편집기 창이 열려있는 동안 UP/ DOWN키 를 사용해야합니다 . 이것은 Helios (Eclipse 3.6)와 함께 작동합니다. 이전 버전의 Eclipse에 해당되는지 확실하지 않습니다.

원하는 편집기가 나올 때까지 길게 CTRL누른 F6다음 손을 release니다. UI는 창 선택만큼 아름답지는 않지만 기능은 동일합니다.

SLES12 시스템에서는 Ctrl+ PageUp및 Ctrl+ PageDown를 사용하여 기본적으로 탭 사이를 탐색 할 수 있습니다 . "일반"범주 아래의 "키"섹션을 탐색하여 언제든지 기본 설정 창에서 이러한 키를 변경할 수 있습니다. 이 과정은 위의 Victor와 VonC에 의해 잘 설명되어 있습니다.

Eclipse에서 열린 창 사이를 전환하는 방법

CTRL + F7은 여기서 작동합니다-Windows의 Eclipse Photon.