/*******************************************************************************
 * Copyright (c) 2007, 2010 Association for Decentralized Information Management
 * in Industry THTH ry.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     VTT Technical Research Centre of Finland - initial API and implementation
 *******************************************************************************/
package org.simantics.workbench.internal;

import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IProduct;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialogWithToggle;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.FileTransfer;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IPageListener;
import org.eclipse.ui.IPartListener2;
import org.eclipse.ui.IPerspectiveDescriptor;
import org.eclipse.ui.IPerspectiveRegistry;
import org.eclipse.ui.IPropertyListener;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPartConstants;
import org.eclipse.ui.IWorkbenchPartReference;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PerspectiveAdapter;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.WorkbenchException;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchWindowAdvisor;
import org.eclipse.ui.internal.ide.AboutInfo;
import org.eclipse.ui.internal.ide.EditorAreaDropAdapter;
import org.eclipse.ui.internal.ide.IDEInternalPreferences;
import org.eclipse.ui.internal.ide.IDEWorkbenchMessages;
import org.eclipse.ui.internal.ide.IDEWorkbenchPlugin;
import org.eclipse.ui.internal.ide.dialogs.WelcomeEditorInput;
import org.eclipse.ui.part.EditorInputTransfer;
import org.eclipse.ui.part.MarkerTransfer;
import org.eclipse.ui.part.ResourceTransfer;
import org.eclipse.ui.statushandlers.StatusManager;
import org.osgi.framework.Bundle;
import org.osgi.framework.BundleContext;
import org.osgi.framework.BundleException;
import org.osgi.framework.ServiceReference;
import org.simantics.db.management.ISessionContextChangedListener;
import org.simantics.db.management.ISessionContextProvider;
import org.simantics.db.management.SessionContextChangedEvent;
import org.simantics.ui.SimanticsUI;
import org.simantics.ui.workbench.WorkbenchShutdownService;


/**
 * System properties used to configure how this class works:
 * <ul>
 * <li><code>org.simantics.workbench.application.showProgressIndicator=true|false (default=true)</code> - Used to initialize IWorkbenchWindowConfigurer.setShowProgressIndicator</li>
 * <li><code>org.simantics.workbench.application.showFastViewBars=true|false (default=true)</code> - Used to initialize IWorkbenchWindowConfigurer.setShowFastViewBars</li>
 * <li><code>org.simantics.workbench.application.showPerspectiveBar=true|false (default=true)</code> - Used to initialize IWorkbenchWindowConfigurer.setShowPerspectiveBar</li>
 * <li><code>org.simantics.workbench.application.excludePerspectiveFromTitle=true|false (default=false)</code> - Used to exclude perspective name in {@link #computeTitle()}</li>
 * </ul>
 * 
 * @author Tuukka Lehtonen
 */
public class SimanticsWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor {

    private static final String WELCOME_EDITOR_ID = "org.eclipse.ui.internal.ide.dialogs.WelcomeEditor"; //$NON-NLS-1$

    protected SimanticsWorkbenchAdvisor wbAdvisor;
    protected boolean editorsAndIntrosOpened = false;
    protected IEditorPart lastActiveEditor = null;
    protected IPerspectiveDescriptor lastPerspective = null;

    protected IWorkbenchPage lastActivePage;
    protected String lastEditorTitle = ""; //$NON-NLS-1$

    private final IPropertyListener editorPropertyListener = new IPropertyListener() {
        @Override
        public void propertyChanged(Object source, int propId) {
            if (propId == IWorkbenchPartConstants.PROP_TITLE) {
                if (lastActiveEditor != null) {
                    String newTitle = lastActiveEditor.getTitle();
                    if (!lastEditorTitle.equals(newTitle)) {
                        recomputeTitle();
                    }
                }
            }
        }
    };

    private IAdaptable lastInput;
    private IWorkbenchAction openPerspectiveAction;

    /**
     * The property change listener.
     * @since 3.6.1
     */
    private IPropertyChangeListener propertyChangeListener;

    /**
     * Return the style bits for the shortcut bar.
     * 
     * @return style bitmask
     */
    protected int perspectiveBarStyle() {
        return SWT.FLAT | SWT.WRAP | SWT.RIGHT | SWT.HORIZONTAL;
    }

    /**
     * Crates a new IDE workbench window advisor.
     * 
     * @param wbAdvisor the workbench advisor
     * @param configurer the window configurer
     */
    public SimanticsWorkbenchWindowAdvisor(SimanticsWorkbenchAdvisor wbAdvisor, IWorkbenchWindowConfigurer configurer) {
        super(configurer);
        this.wbAdvisor = wbAdvisor;
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.application.WorkbenchWindowAdvisor#createActionBarAdvisor(org.eclipse.ui.application.IActionBarConfigurer)
     */
    @Override
    public ActionBarAdvisor createActionBarAdvisor(IActionBarConfigurer configurer) {
        return new SimanticsWorkbenchActionBarAdvisor(configurer);
    }

    /**
     * Returns the workbench.
     * 
     * @return the workbench
     */
    private IWorkbench getWorkbench() {
        return getWindowConfigurer().getWorkbenchConfigurer().getWorkbench();
    }

    private volatile boolean allWindowShellsClosed = false;

    /*
     * (non-Javadoc)
     * 
     * @see org.eclipse.ui.application.WorkbenchAdvisor#preWindowShellClose
     */
    @Override
    public boolean preWindowShellClose() {
        if (getWorkbench().getWorkbenchWindowCount() > 1) {
            return true;
        }

        // WORKAROUND for a workbench problem which causes Eclipse to invoke this method twice:
        // Always return false after true has been returned.
        // Eclipse/SWT or something seems to have a bug of some sort that causes it to receive
        // See https://www.simantics.org/redmine/issues/3848.
        if (allWindowShellsClosed)
            return false;

        // the user has asked to close the last window, while will cause the
        // workbench to close in due course - prompt the user for confirmation
        IPreferenceStore store = IDEWorkbenchPlugin.getDefault()
        .getPreferenceStore();
        boolean promptOnExit = store
        .getBoolean(IDEInternalPreferences.EXIT_PROMPT_ON_CLOSE_LAST_WINDOW);

        if (promptOnExit) {
            String message;

            String productName = null;
            IProduct product = Platform.getProduct();
            if (product != null) {
                productName = product.getName();
            }
            if (productName == null) {
                message = IDEWorkbenchMessages.PromptOnExitDialog_message0;
            } else {
                message = NLS.bind(IDEWorkbenchMessages.PromptOnExitDialog_message1, productName);
            }

            MessageDialogWithToggle dlg = MessageDialogWithToggle
            .openOkCancelConfirm(getWindowConfigurer().getWindow()
                    .getShell(), IDEWorkbenchMessages.PromptOnExitDialog_shellTitle,
                    message, IDEWorkbenchMessages.PromptOnExitDialog_choice,
                    false, null, null);
            if (dlg.getReturnCode() != IDialogConstants.OK_ID) {
                return false;
            }
            if (dlg.getToggleState()) {
                store
                .setValue(
                        IDEInternalPreferences.EXIT_PROMPT_ON_CLOSE_LAST_WINDOW,
                        false);
                IDEWorkbenchPlugin.getDefault().savePluginPreferences();
            }
        }

        // Make sure that it's OK to close even if there are unsaved changes.
        AtomicBoolean saveAtExit = new AtomicBoolean(false);
        if (!ApplicationUtil.allowShutdown(saveAtExit))
            return false;
        wbAdvisor.setSaveAtExit(saveAtExit.get());

        BundleContext context = Activator.getDefault().getBundle().getBundleContext();
        ServiceReference<?> ref = context.getServiceReference(WorkbenchShutdownService.class.getName());
        WorkbenchShutdownService shutdown = (WorkbenchShutdownService)context.getService(ref);
        shutdown.doShutdown();
        context.ungetService(ref);

        allWindowShellsClosed = true;

        return true;
    }

    /**
     * Asks the user whether the workbench should really be closed. Only asks if
     * the preference is enabled.
     * 
     * @param parentShell
     *            the parent shell to use for the confirmation dialog
     * @return <code>true</code> if OK to exit, <code>false</code> if the user
     *         canceled
     * @since 3.6
     */
    static boolean promptOnExit(Shell parentShell) {
        IPreferenceStore store = IDEWorkbenchPlugin.getDefault()
                .getPreferenceStore();
        boolean promptOnExit = store
                .getBoolean(IDEInternalPreferences.EXIT_PROMPT_ON_CLOSE_LAST_WINDOW);

        if (promptOnExit) {
            if (parentShell == null) {
                IWorkbenchWindow workbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
                if (workbenchWindow != null) {
                    parentShell = workbenchWindow.getShell();
                }
            }
            if (parentShell != null) {
                parentShell.setMinimized(false);
                parentShell.forceActive();
            }

            String message;

            String productName = null;
            IProduct product = Platform.getProduct();
            if (product != null) {
                productName = product.getName();
            }
            if (productName == null) {
                message = IDEWorkbenchMessages.PromptOnExitDialog_message0;
            } else {
                message = NLS.bind(
                        IDEWorkbenchMessages.PromptOnExitDialog_message1,
                        productName);
            }

            MessageDialogWithToggle dlg = MessageDialogWithToggle
                    .openOkCancelConfirm(parentShell,
                            IDEWorkbenchMessages.PromptOnExitDialog_shellTitle,
                            message,
                            IDEWorkbenchMessages.PromptOnExitDialog_choice,
                            false, null, null);
            if (dlg.getReturnCode() != IDialogConstants.OK_ID) {
                return false;
            }
            if (dlg.getToggleState()) {
                store
                .setValue(
                        IDEInternalPreferences.EXIT_PROMPT_ON_CLOSE_LAST_WINDOW,
                        false);
                IDEWorkbenchPlugin.getDefault().savePluginPreferences();
            }
        }

        return true;
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.application.WorkbenchAdvisor#preWindowOpen
     */
    @Override
    public void preWindowOpen() {
        IWorkbenchWindowConfigurer configurer = getWindowConfigurer();

        boolean showProgressIndicator = !"false".equals(System.getProperty("org.simantics.workbench.application.showProgressIndicator", "true").toLowerCase());
        boolean showPerspectiveBar    = !"false".equals(System.getProperty("org.simantics.workbench.application.showPerspectiveBar", "true").toLowerCase());

        // show the shortcut bar and progress indicator, which are hidden by default
        configurer.setShowProgressIndicator(showProgressIndicator);
        configurer.setShowPerspectiveBar(showPerspectiveBar);

        // add the drag and drop support for the editor area
        configurer.addEditorAreaTransfer(EditorInputTransfer.getInstance());
        configurer.addEditorAreaTransfer(ResourceTransfer.getInstance());
        configurer.addEditorAreaTransfer(FileTransfer.getInstance());
        configurer.addEditorAreaTransfer(MarkerTransfer.getInstance());
        configurer.configureEditorAreaDropListener(new EditorAreaDropAdapter(
                configurer.getWindow()));

        hookTitleUpdateListeners(configurer);
    }

    /**
     * Hooks the listeners needed on the window
     * @param configurer
     */
    private void hookTitleUpdateListeners(IWorkbenchWindowConfigurer configurer) {
        // hook up the listeners to update the window title
        configurer.getWindow().addPageListener(new IPageListener() {
            @Override
            public void pageActivated(IWorkbenchPage page) {
                updateTitle(false);
            }

            @Override
            public void pageClosed(IWorkbenchPage page) {
                updateTitle(false);
            }

            @Override
            public void pageOpened(IWorkbenchPage page) {
                // do nothing
            }
        });
        configurer.getWindow().addPerspectiveListener(
                new PerspectiveAdapter() {
                    @Override
                    public void perspectiveActivated(IWorkbenchPage page,
                            IPerspectiveDescriptor perspective) {
                        updateTitle(false);
                    }
                    @Override
                    public void perspectiveSavedAs(IWorkbenchPage page,IPerspectiveDescriptor oldPerspective,IPerspectiveDescriptor newPerspective){
                        updateTitle(false);
                    }
                    @Override
                    public void perspectiveDeactivated(IWorkbenchPage page, IPerspectiveDescriptor perspective) {
                        updateTitle(false);
                    }
                });
        configurer.getWindow().getPartService().addPartListener(
                new IPartListener2() {
                    @Override
                    public void partActivated(IWorkbenchPartReference ref) {
                        if (ref instanceof IEditorReference) {
                            updateTitle(false);
                        }
                    }

                    @Override
                    public void partBroughtToTop(IWorkbenchPartReference ref) {
                        if (ref instanceof IEditorReference) {
                            updateTitle(false);
                        }
                    }

                    @Override
                    public void partClosed(IWorkbenchPartReference ref) {
                        updateTitle(false);
                    }

                    @Override
                    public void partDeactivated(IWorkbenchPartReference ref) {
                        // do nothing
                    }

                    @Override
                    public void partOpened(IWorkbenchPartReference ref) {
                        // do nothing
                    }

                    @Override
                    public void partHidden(IWorkbenchPartReference ref) {
                        if (ref.getPart(false) == lastActiveEditor
                                && lastActiveEditor != null) {
                            updateTitle(true);
                        }
                    }

                    @Override
                    public void partVisible(IWorkbenchPartReference ref) {
                        if (ref.getPart(false) == lastActiveEditor
                                && lastActiveEditor != null) {
                            updateTitle(false);
                        }
                    }

                    @Override
                    public void partInputChanged(IWorkbenchPartReference ref) {
                        // do nothing
                    }
                });

        // Update the title when the active UI database session is changed.
        ISessionContextProvider provider = SimanticsUI.getSessionContextProvider(configurer.getWindow());
        provider.addContextChangedListener(new ISessionContextChangedListener() {
            @Override
            public void sessionContextChanged(SessionContextChangedEvent event) {
                IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
                IWorkbenchWindow window = configurer.getWindow();
                if (window == null)
                    return;
                Shell shell = window.getShell();
                if (shell == null || shell.isDisposed())
                    return;
                shell.getDisplay().asyncExec(new Runnable() {
                    @Override
                    public void run() {
                        updateTitle(true);
                    }
                });
            }
        });

        // Listen for changes of the workspace name.
        propertyChangeListener = new IPropertyChangeListener() {
            public void propertyChange(PropertyChangeEvent event) {
                String property = event.getProperty();
                if (IDEInternalPreferences.WORKSPACE_NAME.equals(property)
                        || IDEInternalPreferences.SHOW_LOCATION.equals(property)) {
                    // Make sure the title is actually updated by
                    // setting last active page.
                    lastActivePage = null;
                    updateTitle(false);
                }
            }
        };
        IDEWorkbenchPlugin.getDefault().getPreferenceStore()
                .addPropertyChangeListener(propertyChangeListener);
    }

    protected String computeTitle() {
        IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
        IWorkbenchPage currentPage = configurer.getWindow().getActivePage();
        IEditorPart activeEditor = null;
        if (currentPage != null) {
            activeEditor = lastActiveEditor;
        }

        String title = null;
        IProduct product = Platform.getProduct();
        if (product != null) {
            title = product.getName();
        }
        if (title == null) {
            title = ""; //$NON-NLS-1$
        }

//        ISessionContext ctx = SimanticsUI.getSessionContext(configurer.getWindow());
//        if (ctx != null) {
//            ServerAddress addr = ctx.getAddress();
//            if (addr != null) {
//                title += " - Connected to " + addr.getAddress().getHostName();//InetAddressUtils.toHostString(addr);
//            }
//            Session session = ctx.getSession();
//            if (session != null) {
//                SessionUserSupport sessionUser = session.getService(SessionUserSupport.class);
//                final Resource user = sessionUser.getUser();
//                if (user != null) {
//                    String userName;
//                    try {
//                        userName = session.syncRequest(new Read<String>() {
//                            @Override
//                            public String perform(ReadGraph graph) throws DatabaseException {
//                                try {
//                                    return graph.adapt(user, String.class);
//                                } catch (AdaptionException e) {
//                                    return NameUtils.getSafeName(graph, user);
//                                }
//                            }
//                        });
//                    } catch (DatabaseException e) {
//                        e.printStackTrace();
//                        userName = "ERROR";
//                    }
//
//                    title += " - " + userName;
//                }
//            }
//
//        } else {
//            //title += " - Disconnected";
//        }

        if (currentPage != null) {
            if (activeEditor != null) {
                lastEditorTitle = activeEditor.getTitleToolTip();
                //IDEWorkbenchMessages.WorkbenchWindow_shellTitle == "{0} - {1}"
                title = NLS.bind("{0} - {1}", lastEditorTitle, title);
            }

            boolean excludePerspectiveFromTitle = "true".equals(System.getProperty("org.simantics.workbench.application.excludePerspectiveFromTitle", "false").toLowerCase());
            if (!excludePerspectiveFromTitle) {
                IPerspectiveDescriptor persp = currentPage.getPerspective();
                String label = ""; //$NON-NLS-1$
                if (persp != null) {
                    label = persp.getLabel();
                }
                IAdaptable input = currentPage.getInput();
                if (input != null && !input.equals(wbAdvisor.getDefaultPageInput())) {
                    label = currentPage.getLabel();
                }
                if (label != null && !label.equals("")) { //$NON-NLS-1$
                	//IDEWorkbenchMessages.WorkbenchWindow_shellTitle == "{0} - {1}"
                    title = NLS.bind("{0} - {1}", label, title);
                }
            }
        }

        String workspaceLocation = wbAdvisor.getWorkspaceLocation();
        if (workspaceLocation != null) {
            title = NLS.bind("{0} - {1}", title, workspaceLocation);
        }

        // Bug 284447: Prepend workspace name to the title
        String workspaceName = IDEWorkbenchPlugin.getDefault()
        .getPreferenceStore().getString(
                IDEInternalPreferences.WORKSPACE_NAME);
        if (workspaceName != null && workspaceName.length() > 0) {
        	//IDEWorkbenchMessages.WorkbenchWindow_shellTitle == "{0} - {1}"
            title = NLS.bind("{0} - {1}", workspaceName, title);
        }

        return title;
    }

    private void recomputeTitle() {
        IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
        String oldTitle = configurer.getTitle();
        String newTitle = computeTitle();
        if (!newTitle.equals(oldTitle)) {
            configurer.setTitle(newTitle);
        }
    }

    /**
     * Updates the window title. Format will be:
     * [pageInput -] [currentPerspective -] [editorInput -] [workspaceLocation -] productName
     */
    private void updateTitle(boolean force) {
        IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
        IWorkbenchWindow window = configurer.getWindow();
        IEditorPart activeEditor = null;
        IWorkbenchPage currentPage = window.getActivePage();
        IPerspectiveDescriptor persp = null;
        IAdaptable input = null;

        if (currentPage != null) {
            activeEditor = currentPage.getActiveEditor();
            persp = currentPage.getPerspective();
            input = currentPage.getInput();
        }

        // Nothing to do if the editor hasn't changed or change is not forced.
        if (!force && activeEditor == lastActiveEditor && currentPage == lastActivePage
                && persp == lastPerspective && input == lastInput) {
            return;
        }

        if (lastActiveEditor != null) {
            lastActiveEditor.removePropertyListener(editorPropertyListener );
        }

        lastActiveEditor = activeEditor;
        lastActivePage = currentPage;
        lastPerspective = persp;
        lastInput = input;

        if (activeEditor != null) {
            activeEditor.addPropertyListener(editorPropertyListener);
        }

        recomputeTitle();
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.application.WorkbenchAdvisor#postWindowRestore
     */
    @Override
    public void postWindowRestore()
    throws WorkbenchException {
        IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
        IWorkbenchWindow window = configurer.getWindow();

        int index = getWorkbench().getWorkbenchWindowCount() - 1;

        AboutInfo[] welcomePerspectiveInfos = wbAdvisor.getWelcomePerspectiveInfos();
        if (index >= 0 && welcomePerspectiveInfos != null
                && index < welcomePerspectiveInfos.length) {
            // find a page that exist in the window
            IWorkbenchPage page = window.getActivePage();
            if (page == null) {
                IWorkbenchPage[] pages = window.getPages();
                if (pages != null && pages.length > 0) {
                    page = pages[0];
                }
            }

            // if the window does not contain a page, create one
            String perspectiveId = welcomePerspectiveInfos[index].getWelcomePerspectiveId();
            if (page == null) {
                IAdaptable root = wbAdvisor.getDefaultPageInput();
                page = window.openPage(perspectiveId, root);
            } else {
                IPerspectiveRegistry reg = getWorkbench()
                        .getPerspectiveRegistry();
                IPerspectiveDescriptor desc = reg
                        .findPerspectiveWithId(perspectiveId);
                if (desc != null) {
                    page.setPerspective(desc);
                }
            }

            // set the active page and open the welcome editor
            window.setActivePage(page);
            page.openEditor(new WelcomeEditorInput(
                    welcomePerspectiveInfos[index]), WELCOME_EDITOR_ID, true);
        }
    }

    /**
     * Tries to open the intro, if one exists and otherwise will open the legacy
     * Welcome pages.
     * 
     * @see org.eclipse.ui.application.WorkbenchWindowAdvisor#openIntro()
     */
    @Override
    public void openIntro() {
        if (editorsAndIntrosOpened ) {
            return;
        }

        editorsAndIntrosOpened = true;

        // don't try to open the welcome editors if there is an intro
        if (wbAdvisor.hasIntro()) {
            super.openIntro();
        } else {
            openWelcomeEditors(getWindowConfigurer().getWindow());
            // save any preferences changes caused by the above actions
            IDEWorkbenchPlugin.getDefault().savePluginPreferences();
        }
    }

    /*
     * Open the welcome editor for the primary feature and for any newly
     * installed features.
     */
    private void openWelcomeEditors(IWorkbenchWindow window) {
        if (IDEWorkbenchPlugin.getDefault().getPreferenceStore().getBoolean(
                IDEInternalPreferences.WELCOME_DIALOG)) {
            // show the welcome page for the product the first time the
            // workbench opens
            IProduct product = Platform.getProduct();
            if (product == null) {
                return;
            }

            AboutInfo productInfo = new AboutInfo(product);
            URL url = productInfo.getWelcomePageURL();
            if (url == null) {
                return;
            }

            IDEWorkbenchPlugin.getDefault().getPreferenceStore().setValue(
                    IDEInternalPreferences.WELCOME_DIALOG, false);
            openWelcomeEditor(window, new WelcomeEditorInput(productInfo), null);
        } else {
            // Show the welcome page for any newly installed features
            List<AboutInfo> welcomeFeatures = new ArrayList<AboutInfo>();
            for (Iterator<?> it = wbAdvisor.getNewlyAddedBundleGroups().entrySet()
                    .iterator(); it.hasNext();) {
                Map.Entry<?,?> entry = (Map.Entry<?,?>) it.next();
                AboutInfo info = (AboutInfo) entry.getValue();

                if (info != null && info.getWelcomePageURL() != null) {
                    welcomeFeatures.add(info);
                    // activate the feature plug-in so it can run some install
                    // code
                    String pi = info.getBrandingBundleId();
                    if (pi != null) {
                        // Start the bundle if there is one
                        Bundle bundle = Platform.getBundle(pi);
                        if (bundle != null) {
                            try {
                                bundle.start(Bundle.START_TRANSIENT);
                            } catch (BundleException exception) {
                                StatusManager
                                .getManager()
                                .handle(
                                        new Status(
                                                IStatus.ERROR,
                                                Activator.PLUGIN_ID,
                                                "Failed to load feature", exception));//$NON-NLS-1$
                            }
                        }
                    }
                }
            }

            int wCount = getWorkbench().getWorkbenchWindowCount();
            for (int i = 0; i < welcomeFeatures.size(); i++) {
                AboutInfo newInfo = (AboutInfo) welcomeFeatures.get(i);
                String id = newInfo.getWelcomePerspectiveId();
                // Other editors were already opened in postWindowRestore(..)
                if (id == null || i >= wCount) {
                    openWelcomeEditor(window, new WelcomeEditorInput(newInfo),
                            id);
                }
            }
        }
    }

    /**
     * Open a welcome editor for the given input
     */
    private void openWelcomeEditor(IWorkbenchWindow window,
            WelcomeEditorInput input, String perspectiveId) {
        if (getWorkbench().getWorkbenchWindowCount() == 0) {
            // Something is wrong, there should be at least
            // one workbench window open by now.
            return;
        }

        IWorkbenchWindow win = window;
        if (perspectiveId != null) {
            try {
                win = getWorkbench().openWorkbenchWindow(perspectiveId,
                        wbAdvisor.getDefaultPageInput());
                if (win == null) {
                    win = window;
                }
            } catch (WorkbenchException e) {
                IDEWorkbenchPlugin
                .log(
                        "Error opening window with welcome perspective.", e.getStatus()); //$NON-NLS-1$
                return;
            }
        }

        if (win == null) {
            win = getWorkbench().getWorkbenchWindows()[0];
        }

        IWorkbenchPage page = win.getActivePage();
        String id = perspectiveId;
        if (id == null) {
            id = getWorkbench().getPerspectiveRegistry()
            .getDefaultPerspective();
        }

        if (page == null) {
            try {
                page = win.openPage(id, wbAdvisor.getDefaultPageInput());
            } catch (WorkbenchException e) {
                ErrorDialog.openError(win.getShell(),
                        IDEWorkbenchMessages.Problems_Opening_Page, e
                        .getMessage(), e.getStatus());
            }
        }
        if (page == null) {
            return;
        }

        if (page.getPerspective() == null) {
            try {
                page = getWorkbench().showPerspective(id, win);
            } catch (WorkbenchException e) {
                ErrorDialog
                .openError(
                        win.getShell(),
                        IDEWorkbenchMessages.Workbench_openEditorErrorDialogTitle,
                        IDEWorkbenchMessages.Workbench_openEditorErrorDialogMessage,
                        e.getStatus());
                return;
            }
        }

        page.setEditorAreaVisible(true);

        // see if we already have an editor
        IEditorPart editor = page.findEditor(input);
        if (editor != null) {
            page.activate(editor);
            return;
        }

        try {
            page.openEditor(input, WELCOME_EDITOR_ID);
        } catch (PartInitException e) {
            ErrorDialog
            .openError(
                    win.getShell(),
                    IDEWorkbenchMessages.Workbench_openEditorErrorDialogTitle,
                    IDEWorkbenchMessages.Workbench_openEditorErrorDialogMessage,
                    e.getStatus());
        }
        return;
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.application.WorkbenchAdvisor#createEmptyWindowContents(org.eclipse.ui.application.IWorkbenchWindowConfigurer, org.eclipse.swt.widgets.Composite)
     */
    @Override
    public Control createEmptyWindowContents(Composite parent) {
        final IWorkbenchWindow window = getWindowConfigurer().getWindow();
        Composite composite = new Composite(parent, SWT.NONE);
        composite.setLayout(new GridLayout(2, false));
        Display display = composite.getDisplay();
        Color bgCol = display.getSystemColor(SWT.COLOR_TITLE_INACTIVE_BACKGROUND);
        composite.setBackground(bgCol);
        Label label = new Label(composite, SWT.WRAP);
        label.setForeground(display.getSystemColor(SWT.COLOR_TITLE_INACTIVE_FOREGROUND));
        label.setBackground(bgCol);
        label.setFont(JFaceResources.getFontRegistry().getBold(JFaceResources.DEFAULT_FONT));
        String msg = IDEWorkbenchMessages.IDEWorkbenchAdvisor_noPerspective;
        label.setText(msg);
        ToolBarManager toolBarManager = new ToolBarManager();
        openPerspectiveAction = ActionFactory.OPEN_PERSPECTIVE_DIALOG.create(window);
        toolBarManager.add(openPerspectiveAction);
        ToolBar toolBar = toolBarManager.createControl(composite);
        toolBar.setBackground(bgCol);
        return composite;
    }

    @Override
    public void dispose() {
        if (propertyChangeListener != null) {
            IDEWorkbenchPlugin.getDefault().getPreferenceStore().removePropertyChangeListener(propertyChangeListener);
            propertyChangeListener = null;
        }

        if (openPerspectiveAction!=null) {
            openPerspectiveAction.dispose();
            openPerspectiveAction = null;
        }
        super.dispose();
    }

}