//------------------------------------------------------------------------------
// Copyright (c) 2005, 2007 IBM Corporation and others.
// 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:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.rcp.ui;

import org.eclipse.epf.authoring.ui.AuthoringUIHelpContexts;
import org.eclipse.epf.authoring.ui.views.ViewHelper;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.rcp.ui.actions.NewWizardMenu;
import org.eclipse.epf.rcp.ui.actions.UIActionFactory;
import org.eclipse.epf.rcp.ui.actions.UIOpenPerspectiveDialogAction;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.ActionContributionItem;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.actions.ActionFactory;
import org.eclipse.ui.actions.ContributionItemFactory;
import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction;
import org.eclipse.ui.application.ActionBarAdvisor;
import org.eclipse.ui.application.IActionBarConfigurer;
import org.eclipse.ui.ide.IDEActionFactory;
import org.eclipse.ui.ide.IIDEActionConstants;
import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2;

/**
 * Creates, adds and disposes the actions added to a workbench window.
 * 
 * @author Kelvin Low
 * @author Bingxue Xu
 * @author Phong Nguyen Le
 * @author Jinhua Xi
 * @since 1.0
 */
public class MainActionBarAdvisor extends ActionBarAdvisor {

	// All actions should be created in makeActions and referenced in the
	// fill methods. This ensures that the actions aren't recreated
	// when fillActionBars is called with FILL_PROXY.

	// File actions.
	protected IWorkbenchAction newAction;

	protected IWorkbenchAction closeAction;

	protected IWorkbenchAction closeAllAction;

	protected IWorkbenchAction saveAction;

	protected IWorkbenchAction saveAsAction;

	protected IWorkbenchAction saveAllAction;

	protected IWorkbenchAction revertAction;

	protected IWorkbenchAction moveAction;

	protected IWorkbenchAction renameAction;

	protected IWorkbenchAction refreshAction;

	protected IWorkbenchAction importAction;

	protected IWorkbenchAction exportAction;

	protected IWorkbenchAction propertiesAction;

	protected IWorkbenchAction exitAction;

	// Edit actions.
	protected IWorkbenchAction openElementAction;

	protected IWorkbenchAction undoAction;

	protected IWorkbenchAction redoAction;

	protected IWorkbenchAction cutAction;

	protected IWorkbenchAction copyAction;

	protected IWorkbenchAction pasteAction;

	protected IWorkbenchAction deleteAction;

	protected IWorkbenchAction selectAllAction;

	protected IWorkbenchAction findAction;

	// Navigate actions.
	protected IWorkbenchAction goIntoAction;

	protected IWorkbenchAction nextAction;

	protected IWorkbenchAction previousAction;

	protected IWorkbenchAction backAction;

	protected IWorkbenchAction forwardAction;

	// Window actions.
	protected IWorkbenchAction openNewWindowAction;

	protected IWorkbenchAction openPerspectiveDialogAction;

	protected IWorkbenchAction customizePerspectiveAction;

	protected IWorkbenchAction savePerspectiveAction;

	protected IWorkbenchAction resetPerspectiveAction;

	protected IWorkbenchAction closePerspectiveAction;

	protected IWorkbenchAction closeAllPerspectiveAction;

	protected IWorkbenchAction preferencesAction;

	// Window navigation actions.
	protected IWorkbenchAction nextEditorAction;

	protected IWorkbenchAction previousEditorAction;

	protected IWorkbenchAction nextPartAction;

	protected IWorkbenchAction previousPartAction;

	protected IWorkbenchAction nextPerspectiveAction;

	protected IWorkbenchAction previousPerspectiveAction;

	// Help actions.
	protected IWorkbenchAction welcomeAction;

	protected IWorkbenchAction helpContentsAction;

	protected IWorkbenchAction aboutAction;

	protected IWorkbenchAction newWizardDropDownAction;

	protected IWorkbenchAction lockToolBarAction;

	protected IWorkbenchAction editActionSetAction;

	protected MenuManager mainHelpMenu;

	protected MenuManager mainFileMenu;

	protected MenuManager internalMenu;

	protected IWorkbenchWindow window;

	/**
	 * Creates a new instance.
	 * 
	 * @param configurer
	 *            the action bar configurer
	 */
	public MainActionBarAdvisor(IActionBarConfigurer configurer) {
		super(configurer);
		window = configurer.getWindowConfigurer().getWindow();
	}

	/**
	 * Getd the workbench window.
	 * 
	 * @return the workbench window
	 */
	public IWorkbenchWindow getWindow() {
		return window;
	}

	/**
	 * @see org.eclipse.ui.application.ActionBarAdvisor#makeActions(final
	 *      IWorkbenchWindow window)
	 */
	protected void makeActions(final IWorkbenchWindow window) {
		if (PlatformUI.getWorkbench().isClosing())
			return;

		// Creates the actions and registers them. Registering is needed to
		// ensure that key bindings work. The corresponding commands key
		// bindings are defined in the plugin.xml file. Registering also
		// provides automatic disposal of the actions when the window is closed.

		newAction = ActionFactory.NEW.create(window);
		register(newAction);

		closeAction = ActionFactory.CLOSE.create(window);
		register(closeAction);

		closeAllAction = ActionFactory.CLOSE_ALL.create(window);
		register(closeAllAction);

		saveAction = ActionFactory.SAVE.create(window);
		register(saveAction);

		saveAsAction = ActionFactory.SAVE_AS.create(window);
		register(saveAsAction);

		saveAllAction = ActionFactory.SAVE_ALL.create(window);
		register(saveAllAction);

		revertAction = ActionFactory.REVERT.create(window);
		register(revertAction);

		moveAction = ActionFactory.MOVE.create(window);
		register(moveAction);

		renameAction = ActionFactory.RENAME.create(window);
		register(renameAction);

		refreshAction = ActionFactory.REFRESH.create(window);
		register(refreshAction);

		importAction = UIActionFactory.UI_IMPORT.create(window);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(importAction,
				AuthoringUIHelpContexts.FILE_IMPORT_CONTEXT);
		register(importAction);

		exportAction = UIActionFactory.UI_EXPORT.create(window);
		PlatformUI.getWorkbench().getHelpSystem().setHelp(exportAction,
				AuthoringUIHelpContexts.FILE_EXPORT_CONTEXT);
		register(exportAction);

		propertiesAction = ActionFactory.PROPERTIES.create(window);
		register(propertiesAction);

		exitAction = ActionFactory.QUIT.create(window);
		register(exitAction);

		openElementAction = UIActionFactory.OPEN_ELEMENT.create(window);
		register(openElementAction);

		undoAction = ActionFactory.UNDO.create(window);
		register(undoAction);

		redoAction = ActionFactory.REDO.create(window);
		register(redoAction);

		cutAction = ActionFactory.CUT.create(window);
		register(cutAction);

		copyAction = ActionFactory.COPY.create(window);
		register(copyAction);

		pasteAction = ActionFactory.PASTE.create(window);
		register(pasteAction);

		deleteAction = ActionFactory.DELETE.create(window);
		register(deleteAction);

		selectAllAction = ActionFactory.SELECT_ALL.create(window);
		register(selectAllAction);

		findAction = ActionFactory.FIND.create(window);
		register(findAction);

		goIntoAction = ActionFactory.GO_INTO.create(window);
		register(goIntoAction);

		nextAction = ActionFactory.NEXT.create(window);
		register(nextAction);

		previousAction = ActionFactory.PREVIOUS.create(window);
		register(previousAction);

		backAction = ActionFactory.BACK.create(window);
		register(backAction);

		forwardAction = ActionFactory.FORWARD.create(window);
		register(forwardAction);

		openNewWindowAction = ActionFactory.OPEN_NEW_WINDOW.create(window);
		register(openNewWindowAction);

		nextEditorAction = ActionFactory.NEXT_EDITOR.create(window);
		register(nextEditorAction);

		previousEditorAction = ActionFactory.PREVIOUS_EDITOR.create(window);
		register(previousEditorAction);

		nextPartAction = ActionFactory.NEXT_PART.create(window);
		register(nextPartAction);

		previousPartAction = ActionFactory.PREVIOUS_PART.create(window);
		register(previousPartAction);

		nextPerspectiveAction = ActionFactory.NEXT_PERSPECTIVE.create(window);
		register(nextPerspectiveAction);

		previousPerspectiveAction = ActionFactory.PREVIOUS_PERSPECTIVE
				.create(window);
		register(previousPerspectiveAction);

		openPerspectiveDialogAction = createTNGOpenPerspectiveDialogAction(window);
		openPerspectiveDialogAction.setText(RCPUIResources.otherMenuItem_text);
		register(openPerspectiveDialogAction);

		customizePerspectiveAction = ActionFactory.EDIT_ACTION_SETS
				.create(window);
		register(customizePerspectiveAction);

		savePerspectiveAction = ActionFactory.SAVE_PERSPECTIVE.create(window);
		register(savePerspectiveAction);

		resetPerspectiveAction = ActionFactory.RESET_PERSPECTIVE.create(window);
		register(resetPerspectiveAction);

		closePerspectiveAction = ActionFactory.CLOSE_PERSPECTIVE.create(window);
		register(closePerspectiveAction);

		closeAllPerspectiveAction = ActionFactory.CLOSE_ALL_PERSPECTIVES
				.create(window);
		register(closeAllPerspectiveAction);

		preferencesAction = ActionFactory.PREFERENCES.create(window);
		register(preferencesAction);

		welcomeAction = UIActionFactory.SHOW_INTRO.create(window);
		register(welcomeAction);
		ImageDescriptor imgDes = RCPUIPlugin.getDefault().getImageDescriptor(
				"full/obj16/product.gif"); //$NON-NLS-1$
		welcomeAction.setImageDescriptor(imgDes);

		helpContentsAction = ActionFactory.HELP_CONTENTS.create(window);
		register(helpContentsAction);

		aboutAction = ActionFactory.ABOUT.create(window);
		register(aboutAction);
		
		// FIXME! Filter out Project... from the drop-down menu.
		newWizardDropDownAction = IDEActionFactory.NEW_WIZARD_DROP_DOWN
				.create(window);
		register(newWizardDropDownAction);

		lockToolBarAction = ActionFactory.LOCK_TOOL_BAR.create(window);
		register(lockToolBarAction);

		editActionSetAction = ActionFactory.EDIT_ACTION_SETS.create(window);
		register(editActionSetAction);
	}

	/**
	 * @see org.eclipse.ui.application.ActionBarAdvisor#fillMenuBar(IMenuManager
	 *      menuBar)
	 */
	protected void fillMenuBar(IMenuManager menuBar) {
		if (PlatformUI.getWorkbench().isClosing())
			return;
		mainFileMenu = createFileMenu(menuBar);
		menuBar.add(mainFileMenu);
		menuBar.add(createEditMenu(menuBar));

		IMenuManager navManager = createNavigateMenu(menuBar);
		menuBar.add(navManager);
		navManager.setVisible(false);

		menuBar.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
		menuBar.add(createWindowMenu(menuBar));

		mainHelpMenu = createHelpMenu(menuBar);
		menuBar.add(mainHelpMenu);
	}

	/**
	 * Gets the File menu manager.
	 */
	public MenuManager getFileMenuManager() {
		return mainFileMenu;
	}

	/**
	 * Gets the Help menu manager.
	 */
	public MenuManager getHelpMenuManager() {
		return mainHelpMenu;
	}

	/**
	 * @see org.eclipse.ui.application.ActionBarAdvisor#fillCoolBar(ICoolBarManager
	 *      coolBar)
	 */
	protected void fillCoolBar(ICoolBarManager coolBar) {
		if (PlatformUI.getWorkbench().isClosing())
			return;
		coolBar.add(createFileToolbar(coolBar));
	}

	/**
	 * Creates the File menu.
	 */
	protected MenuManager createFileMenu(IMenuManager menuBar) {
		MenuManager fileMenu = new MenuManager(
				RCPUIResources.fileMenuItem_text,
				IWorkbenchActionConstants.M_FILE);
		fileMenu.add(new GroupMarker(IWorkbenchActionConstants.FILE_START));

		// Create the New sub menu, using the same id for it as the New action.
		String newText = RCPUIResources.fileNewMenuItem_text;
		String newId = ActionFactory.NEW.getId();
		MenuManager newMenu = new MenuManager(newText, newId) {
			public String getMenuText() {
				return super.getMenuText();
			}
		};
		newMenu.add(new Separator(newId));
		newMenu.add(new NewWizardMenu(getWindow(), null));
		newMenu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
		fileMenu.add(newMenu);
		fileMenu.add(new GroupMarker(IWorkbenchActionConstants.NEW_EXT));
		
		//Alex: The below comment out code has nothing with UI, but adding confuse.
		//The real open menu come from /org.eclipse.epf.library.ui/plugin.xml
//		
//		MenuManager openSubMenu = new MenuManager(
//				RCPUIResources.fileOpenMenuItem_text,
//				IWorkbenchActionConstants.OPEN_EXT);
//		openSubMenu
//				.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
//		openSubMenu.add(new Separator());
//		fileMenu.add(openSubMenu);
//		

		fileMenu.add(new Separator());
		fileMenu.add(closeAction);
		fileMenu.add(closeAllAction);
		fileMenu.add(new Separator());
		fileMenu.add(saveAction);
		fileMenu.add(saveAsAction);
		fileMenu.add(saveAllAction);
		fileMenu.add(revertAction);
		fileMenu.add(new Separator());
		fileMenu.add(moveAction);
		fileMenu.add(renameAction);
		fileMenu.add(refreshAction);
		fileMenu.add(new Separator());
		fileMenu.add(new GroupMarker("udt")); //$NON-NLS-1$
		fileMenu.add(new Separator());
		fileMenu.add(new GroupMarker("report")); //$NON-NLS-1$
		fileMenu.add(new Separator());
		fileMenu.add(importAction);
		fileMenu.add(exportAction);
		fileMenu.add(new Separator());
		fileMenu.add(propertiesAction);
		fileMenu.add(new Separator());
		fileMenu.add(exitAction);
		fileMenu.add(new GroupMarker(IWorkbenchActionConstants.FILE_END));

		return fileMenu;
	}

	/**
	 * Creates the Edit menu.
	 */
	protected MenuManager createEditMenu(IMenuManager menuBar) {
		MenuManager editMenu = new MenuManager(
				RCPUIResources.editMenuItem_text,
				IWorkbenchActionConstants.M_EDIT);
		editMenu.add(new GroupMarker(IWorkbenchActionConstants.EDIT_START));
		editMenu.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
		editMenu.add(new Separator());
		editMenu.add(new GroupMarker("opengroup")); //$NON-NLS-1$
		editMenu.add(openElementAction);
		editMenu.add(cutAction);
		editMenu.add(copyAction);
		editMenu.add(pasteAction);
		editMenu.add(new Separator());
		editMenu.add(deleteAction);
		editMenu.add(selectAllAction);
		editMenu.add(new Separator());
		editMenu.add(findAction);
		editMenu.add(new GroupMarker(IWorkbenchActionConstants.EDIT_END));
		return editMenu;
	}

	/**
	 * Creates the Navigate menu.
	 */
	protected MenuManager createNavigateMenu(IMenuManager menuBar) {
		MenuManager navMenu = new MenuManager(
				RCPUIResources.navigateMenuItem_text,
				IWorkbenchActionConstants.M_NAVIGATE);
		navMenu.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
		navMenu.add(goIntoAction);
		navMenu.add(new Separator());
		navMenu.add(nextAction);
		navMenu.add(previousAction);
		navMenu.add(new Separator());
		navMenu.add(backAction);
		navMenu.add(forwardAction);
		navMenu.add(new GroupMarker(IWorkbenchActionConstants.WB_END));
		return navMenu;
	}

	/**
	 * Creates the Window menu.
	 */
	protected MenuManager createWindowMenu(IMenuManager menuBar) {
		MenuManager windowMenu = new MenuManager(
				RCPUIResources.windowMenuItem_text,
				IWorkbenchActionConstants.M_WINDOW);
		windowMenu.add(new GroupMarker(IWorkbenchActionConstants.WB_START));
		windowMenu.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));

		MenuManager changePerspMenuMgr = new MenuManager(
				RCPUIResources.windowOpenPerspectiveMenuItem_text,
				"openPerspective"); //$NON-NLS-1$
		IContributionItem changePerspMenuItem = ContributionItemFactory.PERSPECTIVES_SHORTLIST
				.create(getWindow());
		changePerspMenuMgr.add(changePerspMenuItem);
		windowMenu.add(changePerspMenuMgr);
		MenuManager showViewMenuMgr = new MenuManager(
				RCPUIResources.windowShowViewMenuItem_text, "showView"); //$NON-NLS-1$
		IContributionItem showViewMenu = ContributionItemFactory.VIEWS_SHORTLIST
				.create(getWindow());
		showViewMenuMgr.add(showViewMenu);
		windowMenu.add(showViewMenuMgr);

		windowMenu.add(new Separator());
		windowMenu.add(customizePerspectiveAction);
		windowMenu.add(savePerspectiveAction);
		windowMenu.add(resetPerspectiveAction);
		windowMenu.add(closePerspectiveAction);
		windowMenu.add(closeAllPerspectiveAction);
		windowMenu.add(new Separator());
		windowMenu.add(preferencesAction);
		windowMenu.add(new GroupMarker(IWorkbenchActionConstants.WB_END));
		return windowMenu;
	}

	protected void createInternalMenu(final IMenuManager helpMmenu) {
		internalMenu = new MenuManager(
				RCPUIResources.mainActionBarAdvisor_Diagnosis, ""); //$NON-NLS-1$

		internalMenu.add(new Action(
				RCPUIResources.mainActionBarAdvisor_HealthCheck) {
			public void run() {
				ViewHelper.checkLibraryHealth(LibraryService.getInstance().getCurrentMethodLibrary());
			}
		});
	}

	/**
	 * Creates the Help menu.
	 */
	protected MenuManager createHelpMenu(IMenuManager menuBar) {
		MenuManager helpMmenu = new MenuManager(
				RCPUIResources.helpMenuItem_text,
				IWorkbenchActionConstants.M_HELP);
		helpMmenu.add(new GroupMarker(IWorkbenchActionConstants.HELP_START));
		helpMmenu.add(welcomeAction);

		helpMmenu.add(new Separator());
		helpMmenu.add(helpContentsAction);
		helpMmenu.add(new GroupMarker("group.help")); //$NON-NLS-1$

		helpMmenu.add(new Separator());
		helpMmenu.add(new GroupMarker("group.assist")); //$NON-NLS-1$

		helpMmenu.add(new Separator());
		helpMmenu.add(new GroupMarker("group.tools")); //$NON-NLS-1$

		helpMmenu.add(new Separator());
		helpMmenu.add(new GroupMarker("group.updates")); //$NON-NLS-1$

		// Menu items for internal tool
		helpMmenu.add(new Separator());
		helpMmenu.add(new GroupMarker("group.internal")); //$NON-NLS-1$
		createInternalMenu(helpMmenu);

		helpMmenu.add(new Separator());
		helpMmenu.add(aboutAction);
		helpMmenu.add(new GroupMarker(IWorkbenchActionConstants.HELP_END));

		return helpMmenu;
	}

	/**
	 * Creates the File toolbar.
	 */
	protected IToolBarManager createFileToolbar(ICoolBarManager coolBar) {
		IActionBarConfigurer2 actionBarConfigurer = (IActionBarConfigurer2) getActionBarConfigurer();
		IMenuManager popUpMenu = new MenuManager();
		popUpMenu.add(new ActionContributionItem(lockToolBarAction));
		popUpMenu.add(new ActionContributionItem(editActionSetAction));
		coolBar.setContextMenuManager(popUpMenu);

		coolBar.add(new GroupMarker(IIDEActionConstants.GROUP_FILE));
		IToolBarManager fileToolBar = actionBarConfigurer
				.createToolBarManager();
		fileToolBar.add(new Separator(IWorkbenchActionConstants.NEW_GROUP));
		fileToolBar.add(newWizardDropDownAction);
		fileToolBar.add(new GroupMarker(IWorkbenchActionConstants.NEW_EXT));
		fileToolBar.add(new GroupMarker(IWorkbenchActionConstants.SAVE_GROUP));
		fileToolBar.add(saveAction);
		fileToolBar.add(saveAllAction);
		fileToolBar.add(new GroupMarker(IWorkbenchActionConstants.SAVE_EXT));
		fileToolBar.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));

		return fileToolBar;
	}

	/**
	 * Create a custom open perspective dialog
	 * 
	 * @param window
	 * @return
	 */
	protected IWorkbenchAction createTNGOpenPerspectiveDialogAction(
			IWorkbenchWindow window) {
		if (window == null) {
			throw new IllegalArgumentException();
		}
		IWorkbenchAction action = new UIOpenPerspectiveDialogAction(window);
		action.setId("openPerspectiveDialog"); //$NON-NLS-1$
		return action;
	}

}