bundles/org.eclipse.ui.workbench/Eclipse UI/org/eclipse/ui/internal/WorkbenchWindowConfigurer.java

/*******************************************************************************
 * Copyright (c) 2003, 2015 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Lars Vogel <Lars.Vogel@vogella.com> - Bug 441184, 440136
 *     Denis Zygann <d.zygann@web.de> - Bug 457390
 *******************************************************************************/
package org.eclipse.ui.internal;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IContributionItem;
import org.eclipse.jface.action.ICoolBarManager;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.action.IToolBarManager;
import org.eclipse.jface.internal.provisional.action.IToolBarContributionItem;
import org.eclipse.jface.internal.provisional.action.ToolBarContributionItem2;
import org.eclipse.jface.internal.provisional.action.ToolBarManager2;
import org.eclipse.jface.window.Window;
import org.eclipse.osgi.util.TextProcessor;
import org.eclipse.swt.SWT;
import org.eclipse.swt.dnd.DropTargetListener;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.IMemento;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.application.IActionBarConfigurer;
import org.eclipse.ui.application.IWorkbenchConfigurer;
import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
import org.eclipse.ui.application.WorkbenchAdvisor;
import org.eclipse.ui.internal.provisional.application.IActionBarConfigurer2;

/**
 * Internal class providing special access for configuring workbench windows.
 * <p>
 * Note that these objects are only available to the main application (the
 * plug-in that creates and owns the workbench).
 * </p>
 * <p>
 * This class is not intended to be instantiated or subclassed by clients.
 * </p>
 *
 * @since 3.0
 */
public final class WorkbenchWindowConfigurer implements IWorkbenchWindowConfigurer {

	/**
	 * The workbench window associated with this configurer.
	 */
	private WorkbenchWindow window;

	/**
	 * The shell style bits to use when the window's shell is being created.
	 */
	private int shellStyle = SWT.SHELL_TRIM | Window.getDefaultOrientation();

	/**
	 * The window title to set when the window's shell has been created.
	 */
	private String windowTitle;

	/**
	 * Whether the workbench window should show the perspective bar
	 */
	private boolean showPerspectiveBar = false;

	/**
	 * Whether the workbench window should show the status line.
	 */
	private boolean showStatusLine = true;

	/**
	 * Whether the workbench window should show the main tool bar.
	 */
	private boolean showToolBar = true;

	/**
	 * Whether the workbench window should show the main menu bar.
	 */
	private boolean showMenuBar = true;

	/**
	 * Whether the workbench window should have a progress indicator.
	 */
	private boolean showProgressIndicator = false;

	/**
	 * Table to hold arbitrary key-data settings (key type: <code>String</code>,
	 * value type: <code>Object</code>).
	 *
	 * @see #setData
	 */
	private Map extraData = new HashMap(1);

	/**
	 * Holds the list drag and drop <code>Transfer</code> for the editor area
	 */
	private ArrayList transferTypes = new ArrayList(3);

	/**
	 * The <code>DropTargetListener</code> implementation for handling a drop into
	 * the editor area.
	 */
	private DropTargetListener dropTargetListener = null;

	/**
	 * Object for configuring this workbench window's action bars. Lazily
	 * initialized to an instance unique to this window.
	 */
	private WindowActionBarConfigurer actionBarConfigurer = null;

	/**
	 * The initial size to use for the shell.
	 */
	private Point initialSize = new Point(1024, 768);

	/**
	 * Action bar configurer that changes this workbench window. This implementation
	 * keeps track of of cool bar items
	 */
	class WindowActionBarConfigurer implements IActionBarConfigurer2 {

		private IActionBarConfigurer2 proxy;

		/**
		 * Sets the proxy to use, or <code>null</code> for none.
		 *
		 * @param proxy the proxy
		 */
		public void setProxy(IActionBarConfigurer2 proxy) {
			this.proxy = proxy;
		}

		@Override
		public IWorkbenchWindowConfigurer getWindowConfigurer() {
			return window.getWindowConfigurer();
		}

		/**
		 * Returns whether the given id is for a cool item.
		 *
		 * @param the item id
		 * @return <code>true</code> if it is a cool item, and <code>false</code>
		 *         otherwise
		 */
		/* package */boolean containsCoolItem(String id) {
			ICoolBarManager cbManager = getCoolBarManager();
			if (cbManager == null) {
				return false;
			}
			IContributionItem cbItem = cbManager.find(id);
			if (cbItem == null) {
				return false;
			}
			// @ issue: maybe we should check if cbItem is visible?
			return true;
		}

		@Override
		public IStatusLineManager getStatusLineManager() {
			if (proxy != null) {
				return proxy.getStatusLineManager();
			}
			return window.getStatusLineManager();
		}

		@Override
		public IMenuManager getMenuManager() {
			if (proxy != null) {
				return proxy.getMenuManager();
			}
			return window.getMenuManager();
		}

		@Override
		public ICoolBarManager getCoolBarManager() {
			if (proxy != null) {
				return proxy.getCoolBarManager();
			}
			return window.getCoolBarManager2();
		}

		@Override
		public void registerGlobalAction(IAction action) {
			if (proxy != null) {
				proxy.registerGlobalAction(action);
			}
			window.registerGlobalAction(action);
		}

		@Override
		public IToolBarManager createToolBarManager() {
			if (proxy != null) {
				return proxy.createToolBarManager();
			}
			return new ToolBarManager2(SWT.WRAP | SWT.FLAT | SWT.RIGHT);
		}

		@Override
		public IToolBarContributionItem createToolBarContributionItem(IToolBarManager toolBarManager, String id) {
			if (proxy != null) {
				return proxy.createToolBarContributionItem(toolBarManager, id);
			}
			return new ToolBarContributionItem2(toolBarManager, id);
		}
	}

	/**
	 * Creates a new workbench window configurer.
	 * <p>
	 * This method is declared package-private. Clients obtain instances via
	 * {@link WorkbenchAdvisor#getWindowConfigurer
	 * WorkbenchAdvisor.getWindowConfigurer}
	 * </p>
	 *
	 * @param window the workbench window that this object configures
	 * @see WorkbenchAdvisor#getWindowConfigurer
	 */
	WorkbenchWindowConfigurer(WorkbenchWindow window) {
		if (window == null) {
			throw new IllegalArgumentException();
		}
		this.window = window;
		windowTitle = WorkbenchPlugin.getDefault().getProductName();
		if (windowTitle == null) {
			windowTitle = ""; //$NON-NLS-1$
		}
	}

	@Override
	public IWorkbenchWindow getWindow() {
		return window;
	}

	@Override
	public IWorkbenchConfigurer getWorkbenchConfigurer() {
		return Workbench.getInstance().getWorkbenchConfigurer();
	}

	/**
	 * Returns the title as set by <code>setTitle</code>, without consulting the
	 * shell.
	 *
	 * @return the window title as set, or <code>null</code> if not set
	 */
	/* package */String basicGetTitle() {
		return windowTitle;
	}

	@Override
	public String getTitle() {
		Shell shell = window.getShell();
		if (shell != null && !shell.isDisposed()) {
			// update the cached title
			windowTitle = shell.getText();
		}
		return windowTitle;
	}

	@Override
	public void setTitle(String title) {
		if (title == null) {
			throw new IllegalArgumentException();
		}
		windowTitle = title;
		Shell shell = window.getShell();
		if (shell != null && !shell.isDisposed()) {
			shell.setText(TextProcessor.process(title, WorkbenchWindow.TEXT_DELIMITERS));
		}
	}

	@Override
	public boolean getShowMenuBar() {
		return showMenuBar;
	}

	@Override
	public void setShowMenuBar(boolean show) {
		showMenuBar = show;
		WorkbenchWindow win = (WorkbenchWindow) getWindow();
		Shell shell = win.getShell();
		if (shell != null) {
			boolean showing = shell.getMenuBar() != null;
			if (show != showing) {
				if (show) {
					shell.setMenuBar(null);
				} else {
					shell.setMenuBar(null);
				}
			}
		}
	}

	@Override
	public boolean getShowCoolBar() {
		return showToolBar;
	}

	@Override
	public void setShowCoolBar(boolean show) {
		showToolBar = show;
		// @issue need to be able to reconfigure after window's controls created
	}

	@Override
	public boolean getShowFastViewBars() {
		// not supported anymore
		return false;
	}

	@Override
	public void setShowFastViewBars(boolean show) {
		// not supported anymore
	}

	@Override
	public boolean getShowPerspectiveBar() {
		return showPerspectiveBar;
	}

	@Override
	public void setShowPerspectiveBar(boolean show) {
		showPerspectiveBar = show;
		// @issue need to be able to reconfigure after window's controls created
	}

	@Override
	public boolean getShowStatusLine() {
		return showStatusLine;
	}

	@Override
	public void setShowStatusLine(boolean show) {
		showStatusLine = show;
		window.setStatusLineVisible(show);
		// @issue need to be able to reconfigure after window's controls created
	}

	@Override
	public boolean getShowProgressIndicator() {
		return showProgressIndicator;
	}

	@Override
	public void setShowProgressIndicator(boolean show) {
		showProgressIndicator = show;
		// @issue need to be able to reconfigure after window's controls created
	}

	@Override
	public Object getData(String key) {
		if (key == null) {
			throw new IllegalArgumentException();
		}
		return extraData.get(key);
	}

	@Override
	public void setData(String key, Object data) {
		if (key == null) {
			throw new IllegalArgumentException();
		}
		if (data != null) {
			extraData.put(key, data);
		} else {
			extraData.remove(key);
		}
	}

	@Override
	public void addEditorAreaTransfer(Transfer tranfer) {
		if (tranfer != null && !transferTypes.contains(tranfer)) {
			transferTypes.add(tranfer);
		}
	}

	@Override
	public void configureEditorAreaDropListener(DropTargetListener dropTargetListener) {
		this.dropTargetListener = dropTargetListener;
	}

	/**
	 * Returns the array of <code>Transfer</code> added by the application
	 */
	/* package */Transfer[] getTransfers() {
		Transfer[] transfers = new Transfer[transferTypes.size()];
		transferTypes.toArray(transfers);
		return transfers;
	}

	/**
	 * Returns the drop listener provided by the application.
	 */
	/* package */DropTargetListener getDropTargetListener() {
		return dropTargetListener;
	}

	@Override
	public IActionBarConfigurer getActionBarConfigurer() {
		if (actionBarConfigurer == null) {
			// lazily initialize
			actionBarConfigurer = new WindowActionBarConfigurer();
		}
		return actionBarConfigurer;
	}

	/**
	 * Returns whether the given id is for a cool item.
	 *
	 * @param the item id
	 * @return <code>true</code> if it is a cool item, and <code>false</code>
	 *         otherwise
	 */
	/* package */boolean containsCoolItem(String id) {
		// trigger lazy initialization
		getActionBarConfigurer();
		return actionBarConfigurer.containsCoolItem(id);
	}

	@Override
	public int getShellStyle() {
		return shellStyle;
	}

	@Override
	public void setShellStyle(int shellStyle) {
		this.shellStyle = shellStyle;
	}

	@Override
	public Point getInitialSize() {
		return initialSize;
	}

	@Override
	public void setInitialSize(Point size) {
		initialSize = size;
	}

	/**
	 * Creates the default window contents.
	 *
	 * @param shell the shell
	 */
	public void createDefaultContents(Shell shell) {

	}

	@Override
	public Menu createMenuBar() {
		return null;
	}

	@Override
	public Control createCoolBarControl(Composite parent) {

		return null;
	}

	@Override
	public Control createStatusLineControl(Composite parent) {
		return null;
	}

	@Override
	public Control createPageComposite(Composite parent) {
		return null;
	}

	@Override
	public IStatus saveState(IMemento memento) {
		return null;
	}

}