Eclipse rcp在eclipse应用程序中禁用退出按钮

Question

如何禁用窗口右上角的按钮来关闭应用程序？

非常感谢

Answer 1

我不认为你可以禁用它（如使其灰色），因为它是由底层操作系统窗口管理器直接管理，而不是由SWT。

您可以添加，虽然监听器，以忽略任何关闭事件，有点像this snippet：

import org.eclipse.swt.*; 
import org.eclipse.swt.widgets.*; 

public class Snippet99 { 

public static void main (String [] args) { 
    Display display = new Display(); 
    final Shell shell = new Shell (display); 
    shell.addListener (SWT.Close, new Listener() { 
     public void handleEvent (Event event) { 
      int style = SWT.APPLICATION_MODAL | SWT.YES | SWT.NO; 
      MessageBox messageBox = new MessageBox (shell, style); 
      messageBox.setText ("Information"); 
      messageBox.setMessage ("Close the shell?"); 
      event.doit = messageBox.open() == SWT.YES; 
     } 
    }); 
    shell.pack(); 
    shell.open(); 
    while (!shell.isDisposed()) { 
     if (!display.readAndDispatch()) display.sleep(); 
    } 
    display.dispose(); 
} 
} 

在你的情况，只需设置“event.doit”到false。

Answer 2

如果用户想要关闭应用程序，另一种可能是“图标化”应用程序，这意味着应用程序被移入托盘项目中。将以下内容添加到ApplicationWorkbenchWindowAdvisor：

a。覆盖postWindowOpen

 
public void postWindowOpen() { 
    Shell shell = getWindowConfigurer().getWindow().getShell(); 
    boolean trayEnabled = false; 
    trayEnabled = enableTray(); 
} 

b。执行托盘支持

 
    /* Enable System-Tray Support */ 
    private boolean enableTray() { 
     /* Avoid that this is being called redundantly */ 
     if (this.fTrayEnabled) { 
      return true; 
     } 
     /* Only enable for Primary Window */ 
     IWorkbenchWindow primaryWindow = PlatformUI.getWorkbench().getWorkbenchWindows()[0]; 
     if (primaryWindow == null || !primaryWindow.equals(getWindowConfigurer().getWindow())) { 
      return false; 
     } 

     final Shell shell = primaryWindow.getShell(); 
     final Tray tray = shell.getDisplay().getSystemTray(); 

     /* Tray not support on the OS */ 
     if (tray == null) { 
      return false; 
     } 

     /* Create Item in Tray */ 
     this.fTrayItem = new TrayItem(tray, SWT.NONE); 
     this.fTrayItem.setToolTipText(Platform.getProduct().getName()); 
     this.fTrayEnabled = true; 

     this.fTrayItem.setVisible(false); 
     /* Apply Image */ 
     this.fTrayItem.setImage(trayIcon); 
     /* Minimize to Tray on Shell Iconify if set */ 
     this.fTrayShellListener = new ShellAdapter() { 
      @Override 
      public void shellIconified(final ShellEvent e) { 
       if (!ApplicationWorkbenchWindowAdvisor.this.fBlockIconifyEvent && ApplicationWorkbenchWindowAdvisor.this.fMinimizeFromClose) { 
        moveToTray(shell); 
       } 
      } 
     }; 
     shell.addShellListener(this.fTrayShellListener); 

     /* Show Menu on Selection */ 
     this.fTrayItem.addListener(SWT.MenuDetect, new Listener() { 


      public void handleEvent(final Event event) { 
       MenuManager trayMenu = new MenuManager(); 

       /* Restore */ 
       trayMenu.add(new ContributionItem() { 
        @Override 
        public void fill(final Menu menu, final int index) { 
         MenuItem restoreItem = new MenuItem(menu, SWT.PUSH); 
         restoreItem.setText("Restore from Tray"); 
         restoreItem.addSelectionListener(new SelectionAdapter() { 
          @Override 
          public void widgetSelected(final SelectionEvent e) { 
           restoreFromTray(shell); 
          } 
         }); 
         menu.setDefaultItem(restoreItem); 
        } 
       }); 

       /* Separator */ 
       trayMenu.add(new Separator()); 

       /* Other Items */ 
       ApplicationWorkbenchWindowAdvisor.this.fActionBarAdvisor.fillTrayItem(trayMenu); 

       Menu menu = trayMenu.createContextMenu(shell); 
       menu.setVisible(true); 
      } 
     }); 
     /* Handle DefaultSelection */ 
     this.fTrayItem.addListener(SWT.DefaultSelection, new Listener() { 
      public void handleEvent(final Event event) { 
       /* Restore from Tray */ 
       if (!shell.isVisible()) { 
        restoreFromTray(shell); 
       } else { 
        moveToTray(shell); 
       } 
      } 
     }); 
     return true; 
    } 
    /* Move to System Tray */ 
    private void moveToTray(final Shell shell) { 
     this.fTrayItem.setVisible(true); 
     this.fBlockIconifyEvent = true; 
     try { 
      shell.setVisible(false); 
     } finally { 
      this.fBlockIconifyEvent = false; 
     } 

     this.fMinimizedToTray = true; 
    /** 
    * @param shell 
    */ 
    public void restoreFromTray(final Shell shell) { 

     /* Restore Shell */ 
     shell.setVisible(true); 
     shell.setActive(); 
     shell.layout(true); 

     /* Un-Minimize if minimized */ 
     if (shell.getMinimized()) { 
      shell.setMinimized(false); 
     } 
     this.fTrayItem.setVisible(false); 

     if (this.fTrayTeasing) { 
      this.fTrayItem.setImage(this.trayImage); 
     } 

     this.fTrayTeasing = false; 
     this.fMinimizedToTray = false; 
    } 

    /* Disable System-Tray Support */ 
    private void disableTray() { 

     /* Avoid that this is being called redundantly */ 
     if (!this.fTrayEnabled) { 
      return; 
     } 

     /* First make sure to have the Window restored */ 
     restoreFromTray(getWindowConfigurer().getWindow().getShell()); 

     this.fTrayEnabled = false; 
     this.fMinimizedToTray = false; 

     if (this.fTrayItem != null) { 
      this.fTrayItem.dispose(); 
     } 

     if (this.fTrayShellListener != null) { 
      getWindowConfigurer().getWindow().getShell().removeShellListener(this.fTrayShellListener); 
     } 
    } 

c。覆盖preWindowShellClose

 
@Override 
public boolean preWindowShellClose() { 
    final res = true ; 
    this.fMinimizeFromClose = true; 
    getWindowConfigurer().getWindow().getShell().notifyListeners(SWT.Iconify, new Event()); 
    res = false; 
    this.fMinimizeFromClose = false; 
    return res; 
} 

HTH 汤姆