Eclipse rcp disable exit button in an eclipse application

Question

how can I disable the window top-right button to close application?

Thanks a lot

Answer 1

Another possibility is to "iconify" the application if the user wants to close the application, that means the application is moved into the tray-item. Add the following to your ApplicationWorkbenchWindowAdvisor:

a. Override postWindowOpen

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

b. Implement tray support

    /* 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. Override 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 Tom

Answer 2

I don't think you can disable it (like make it gray) since it is managed by the underlying OS window manager, not by SWT directly.

You can add a listener though, in order to ignore any close event, a bit like in 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 ();
}
}

In your case, simply set 'event.doit' to false.