Eclipse HotKey：如何在选项卡之间切换？

Question

如何在 Eclipse 中打开的窗口之间切换？有 Ctrl+F6，但它问我想要哪一个，但我想像浏览器中的选项卡或操作系统中的窗口一样切换它（Cmd/Win+Tab），无需从列表中选择文件。如何在 Eclipse 中完成这个简单的事情？

我尝试为事件分配热键：

• 转发
• 历史记录
• 下一页

，但它不能按我想要的方式工作。

Answer 1

• CTRL+E（用于编辑器列表）
• CTRL+F6（用于通过列表）
  您可以为“下一个编辑器”键分配另一个快捷键。

是两个官方快捷方式，但它们都涉及显示列表。

CTRL+Page Up / CTRL+Page Down 可以在编辑器之间循环而不显示列表。

最后一组快捷键的有趣之处在于：
它们未在要定义的 Eclipse Keys 快捷键中列出。
它们可能是从多页编辑器继承的，使它们成为操作系统特定的快捷方式。

---

关于 Mac OS (OSX) 上的快捷方式，Matt Ball 在 2011 年 9 月抱怨无法重新映射CTRL+向上翻页/CTRL+向下翻页：

它让我发疯，因为我无法像 OS X 中的几乎所有其他选项卡式程序一样翻阅打开的选项卡（⌘-Left 和 ⌘-右）。

好吧，2012 年 3 月，Arthur 回复道：

，我刚刚下载了最新版本的 Eclipse (3.7+)。我已经能够将“上一个/下一个选项卡”绑定到 (⌘-Left 和 ⌘-Right ）在编辑器中时，我很确定我以前做不到。
所以我猜他们听到了你的声音。
它的工作方式正如您所期望的那样，选项卡从左到右，反之亦然，而不是基于历史记录或类似的废话。

马特·鲍尔确认：

哇哦，选择“编辑 Java 源代码”确实有效！
现在，不幸的是，这意味着如果我导航到非 Java 文件（JSP、XML、JS 等），我就是 SOL。
解决此问题的方法是为此对“复制命令”，然后选择我想要的所有“时间”。
到目前为止，它至少对于 Java 和 JSP 文件工作得很好。
这是一个需要建立的主要 PITA，但它只是一次性的事情。

他导出的首选项可在此处供您尝试。
导入后，您应该看到所有相关类型的文档：

Answer 2

如果您进入首选项（例如窗口→首选项）并查看常规→按键

，然后搜索“下一个选项卡”和“上一个选项卡”，您可以重新映射它们。

Answer 3

在操作系统中像Windows一样切换（转到最后一个获得焦点的窗口）

CTRL-F6在Eclipse中，就像< strong>ALT-TAB（在 Windows 上），显示可用选项卡/窗口的列表（如果您保留 CTRL< /kbd> / ALT 键被按下）并突出显示当您放开此键时将跳转到的位置。您不必选择该窗口。如果您想一次遍历多个选项卡，请按住 CTRL 按钮并点击 TAB 按钮。这与 Windows 上的 ALT-TAB 行为相同。

从这个意义上来说，eclipse中的CTRL-SHIFT-F6就是ALT-SHIFT-TAB 模拟。就我个人而言，我将 Eclipse 中的这些绑定更改为与 Visual Studio 类似。即 CTRL-TAB 和 CTRL-SHIFT- TAB，我这样做：

Window>Preferences>General>Keys

然后设置“Next Editor”=Ctrl+Tab 和“上一个编辑器”=Ctrl+Shift+Tab。在设置新绑定之前，不要忘记单击“取消绑定命令”。

像浏览器一样切换（转到当前选项卡右侧的选项卡）

这是CTRL-PageDown向右转, CTRL-PageUp 向左移动。令人沮丧的是，当您到达选项卡列表的末尾（例如最右边的选项卡）然后尝试再次向右移动时，Eclipse 不会像大多数浏览器那样循环到第一个选项卡（最左边）。

Answer 4

您可以使用 ALT+向左 转到上一个选项卡，或使用 ALT+向右 前进。不过，此方法使用像历史记录一样的选项卡切换，因此它将转到您打开的上一个选项卡，如果您“后退”一次或多次，则它将前进。我知道有点奇怪，但它确实有效。您始终可以通过单击每个选项卡一次来“重置”历史记录。

Answer 5

• 右侧移动：Ctrl + 向下翻页
• 左侧移动： CTRL + 向上翻页

其他

• 获取打开的选项卡列表：Ctrl + F6

Eclipse 其他快捷方式

• 链接： http://www.shortcutworld.com/en/win/Eclipse.html
• Pdf：http ://eclipse-tools.sourceforge.net/Keyboard_shortcuts_%283.0%29.pdf

Answer 6

CTRL + F6 很好用。如果您想切换到下一个/上一个选项卡，您需要执行 CTRL+Page Down / CTRL+Page Up kbd>。

Answer 7

默认为 Ctrl + F6。您可以通过转到窗口首选项来更改它。我通常将其更改为 Ctrl + Tab，这与我们在浏览器和其他内容中切换选项卡时使用的相同。

Answer 8

返回上一个选项卡的快捷键

Alt + LeftArrow 返回。

Answer 9

自定义键绑定序列示例： CTRL + TAB 使用 Eclipse 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 使用 Eclipse RCP 在可见模块或编辑器 Backword 方向之间切换。

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

插件.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>

Answer 10

3 行 AutoHotKey 脚本（无论如何，在 Windows 上）：

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

将其放入启动文件夹中（另存为 *.ahk，必须安装 AutoHotKey），Eclipse 选项卡现在将像 Chrome 或 Firefox 一样工作。

Answer 11

解决了！！

将方案更改为 Microsoft Visual Studio

窗口 > 首选项 > 常规 > 键

查找方案下拉列表

我的 eclipse 版本：

适用于 Web 开发人员的 Eclipse Java EE IDE。

版本：Juno 服务版本 1
内部版本号：20120920-0800

Answer 12

没有人会读我的答案，但无论如何......如果您使用的是 Mac OS X，您会喜欢在 Eclipse 中进行历史导航的多点触摸手势：

Answer 13

在 Windows 上，如果您有 5 键鼠标，则可以使用前进和后退来代替 ALT+Left 和 ALT+Right。

Answer 14

从右到左：ctrl+ shift + 9 或 ctrl + shift + < kbd>Page Up 或 ctrl + Page Up

从左到右：ctrl + shift + < kbd>3 或 ctrl + shift + Page Down 或 ctrl + Page Down

Answer 15

一种方法是使用 VI 插件，然后你只需执行 :n (和 :N) 在文件之间切换。

这就是我所做的。

Answer 16

您可以在“首选项”->“热键”中设置热键。一般->键（或者只需在“首选项”对话框顶部的筛选字段中键入“键”。

选择“键”部分后，找到“下一个选项卡”和“上一个选项卡”，然后通过单击“绑定”字段然后键入来为它们分配您自己的热键 点击“应用”或“确定”

即可完成该过程。

Answer 17

如果您只想在当前和以前的选项卡选择之间切换，请使用 CTRL + F6 来来回切换。要导航到历史记录中更早的选项卡，您需要在编辑器窗口打开时使用 UP / DOWN 键。这适用于 Helios (Eclipse 3.6)；不确定旧版本的 Eclipse 是否也是如此。

Answer 18

我引用 VonC 的回复，补充一些内容。

• Ctrl+PgUp(PgDn) 在当前堆栈中的选项卡（编辑器和视图）之间切换
• Ctrl+ E 在当前堆栈中的选项卡之间切换，使用过滤列表
• Ctrl+F6 在编辑器之间切换，无论哪个堆栈
• Ctrl+F7 切换视图，无论哪个栈

加上，都有Bug 206299 打开请求使用 Ctrl+Tab 来切换选项卡而不是 Ctrl+< kbd>PgUp(PgDn)。

• 由于这会破坏可访问性，因此用户应该为此设置首选项。也许在 Oomph 安装期间的欢迎调查问卷中应该有一个问题。

如果不满意，您可以为自己分配键绑定，从 Window >首选项>一般>钥匙。

Answer 19

由于某种原因，我的 Eclipse 设置已损坏，因此我必须手动编辑文件 /.plugins/org.eclipse.e4.workbench/workbench.xmi

我之前必须设置过 Ctrl+Tab 到类似于浏览器的选项卡切换，甚至重置 Eclipse 首选项中的所有键绑定也不会摆脱快捷方式（它们也没有显示在任何地方）。我打开上述文件并删除了与不起作用的快捷方式相关的标有 type:user 的 元素。

Answer 20

按住 CTRL 并按 F6 直到到达所需的编辑器，然后松开。 UI 不如窗口选择那么漂亮，但功能是相同的。

Answer 21

在 SLES12 计算机上，默认情况下，您可以使用 Ctrl+PageUp 和 Ctrl+PageDown 在选项卡之间导航。您始终可以通过浏览“常规”类别下的“按键”部分，从“首选项”窗口更改这些按键。
上面 Victor 和 VonC 很好地解释了这个过程。

Answer 22

如何在 Eclipse 中打开的窗口之间切换

CTRL+F7 中打开的窗口之间进行切换 - Eclipse Photon on Windows。

Answer 23

由于某种原因，仅添加新绑定似乎不起作用（eclipse 2021-06）。

相反：

• 使用复制命令克隆下一个选项卡和上一个选项卡
• 将“何时”更改为在Windows中
• 添加新的绑定
• 应用并关闭

@Gillfish 在另一个答案的评论中提到了这一点，但我认为最好明确地显示解决方案。

Answer 24

2022-03 之前的 Eclipse 版本过去使用 CTRL + Tab 按 LRU 顺序在编辑器之间切换，与 CTRL + 相同E - 我相信它具有相同的功能。从 2022 版本开始，不再出现这种情况，使用 CTRL + Tab 而是使用移动到不同的窗格（即从编辑器移动到底部窗格，或从底部窗格到侧栏之一）。

在任何一种情况下， CTRL + Tab 都不会在 Windows-> 首选项 -> 常规 -> 键配置对话框中显示为已使用的绑定 - 看起来进行硬编码。

这真的让我很恼火，因为我非常习惯使用 CTRL + Tab 在多选项卡应用程序中切换选项卡，无论如何，它是比 CTRL + E。

我的解决方案是进入按键配置对话框并将“快速切换编辑器”快捷方式从 CTRL + E 替换为 CTRL + 选项卡。

“快速切换编辑器”基本上就是我所需要的——按一次然后快速释放，你就回到之前使用的编辑器；按一次并按住修饰符 - 您将看到一个菜单，您可以在其中按 LRU 顺序导航到不同的编辑器。