bundles/org.eclipse.ui.workbench/Eclipse UI/org/eclipse/ui/internal/TabbedEditorWorkbook.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2000, 2003 IBM Corporation and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Common Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/cpl-v10.html
  *
  * Contributors:
  *     IBM Corporation - initial API and implementation
  *******************************************************************************/

 package org.eclipse.ui.internal;

 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import org.eclipse.swt.SWT;
 import org.eclipse.swt.custom.CTabFolder;
 import org.eclipse.swt.custom.CTabFolderAdapter;
 import org.eclipse.swt.custom.CTabFolderEvent;
 import org.eclipse.swt.custom.CTabItem;
 import org.eclipse.swt.custom.ViewForm;
 import org.eclipse.swt.events.ControlAdapter;
 import org.eclipse.swt.events.ControlEvent;
 import org.eclipse.swt.events.DisposeEvent;
 import org.eclipse.swt.events.DisposeListener;
 import org.eclipse.swt.events.MouseAdapter;
 import org.eclipse.swt.events.MouseEvent;
 import org.eclipse.swt.events.SelectionAdapter;
 import org.eclipse.swt.events.SelectionEvent;
 import org.eclipse.swt.events.SelectionListener;
 import org.eclipse.swt.graphics.Color;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.graphics.Point;
 import org.eclipse.swt.graphics.Rectangle;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Event;
 import org.eclipse.swt.widgets.Listener;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.swt.widgets.Table;
 import org.eclipse.swt.widgets.TableItem;
 import org.eclipse.swt.widgets.ToolBar;
 import org.eclipse.swt.widgets.ToolItem;

 import org.eclipse.jface.action.ActionContributionItem;
 import org.eclipse.jface.preference.IPreferenceStore;

 import org.eclipse.ui.IEditorReference;

 public class TabbedEditorWorkbook extends EditorWorkbook {

 	private IPreferenceStore preferenceStore = WorkbenchPlugin.getDefault().getPreferenceStore();
 	private int tabLocation = -1; // Initialized in constructor.
 	private CTabFolder tabFolder;
 	private Map mapTabToEditor = new HashMap();
 	private ToolBar pullDownBar;
 	private ToolItem pullDownButton;
 	private EditorList editorList;
 	private ViewForm listComposite;
 	private boolean assignFocusOnSelection = true;
 	private boolean ignoreTabFocusHide = false;
 	private boolean handleTabSelection = true;
 	private boolean mouseDownListenerAdded = false;
 	private boolean usePulldown = false;


 public TabbedEditorWorkbook(EditorArea editorArea) {
 	super(editorArea);

 	// Get tab location preference.
 	if (tabLocation == -1)
 		tabLocation =
 			preferenceStore.getInt(
 				IPreferenceConstants.EDITOR_TAB_POSITION);
 }

 protected Object createItem(EditorPane editorPane) {
 	return createTab(editorPane);
 }

 /**
  * Create a new tab for an item.
  */
 private CTabItem createTab(EditorPane editorPane) {
 	return createTab(editorPane, tabFolder.getItemCount());
 }

 /**
  * Create a new tab for an item at a particular index.
  */
 private CTabItem createTab(EditorPane editorPane, int index) {
 	CTabItem tab = new CTabItem(tabFolder, SWT.NONE, index);
 	mapTabToEditor.put(tab, editorPane);
 	enableDrag(editorPane);
 	updateEditorTab((IEditorReference) editorPane.getPartReference());
 	if (tabFolder.getItemCount() == 1) {
 		if (tabFolder.getTopRight() != null) {
 			pullDownBar.setVisible(true);
 		}
 	}
 	return tab;
 }

 protected void setControlSize() {
 	EditorPane visibleEditor = getVisibleEditor();
 	if (visibleEditor == null || getControl() == null)
 		return;
 	Rectangle bounds = PartTabFolder.calculatePageBounds(tabFolder);
 	visibleEditor.setBounds(bounds);
 	visibleEditor.moveAbove(tabFolder);
 }

 protected void createPresentation(Composite parent) {
 	usePulldown = preferenceStore.getBoolean(IPreferenceConstants.EDITORLIST_PULLDOWN_ACTIVE);

 	tabFolder = new CTabFolder(parent, SWT.BORDER | tabLocation);

 	// prevent close button and scroll buttons from taking focus
 	tabFolder.setTabList(new Control[0]);

 	// redirect drop request to the workbook
 	tabFolder.setData(this);

 	// listener to close the editor
 	tabFolder.addCTabFolderListener(new CTabFolderAdapter() {
 		public void itemClosed(CTabFolderEvent e) {
 			e.doit = false; // otherwise tab is auto disposed on return
 			EditorPane pane = (EditorPane) mapTabToEditor.get(e.item);
 			pane.doHide();
 		}
 	});

 	// listener to switch between visible tabItems
 	tabFolder.addSelectionListener(new SelectionAdapter() {
 		public void widgetSelected(SelectionEvent e) {
 			if (handleTabSelection) {
 				EditorPane pane = (EditorPane) mapTabToEditor.get(e.item);
 				// Pane can be null when tab is just created but not map yet.
 				if (pane != null) {
 					setVisibleEditor(pane);
 					if (assignFocusOnSelection) {
 						// If we get a tab focus hide request, it's from
 						// the previous editor in this workbook which had focus.
 						// Therefore ignore it to avoid paint flicker
 						ignoreTabFocusHide = true;
 						pane.setFocus();
 						ignoreTabFocusHide = false;
 					}
 				}
 			}
 		}
 	});

 	// listener to resize visible components
 	tabFolder.addListener(SWT.Resize, new Listener() {
 		public void handleEvent(Event e) {
 			setControlSize();
 		}
 	});

 	// listen for mouse down on tab area to set focus.
 	tabFolder.addMouseListener(new MouseAdapter() {
 		public void mouseDoubleClick(MouseEvent event) {
 			Rectangle clientArea = tabFolder.getClientArea();
 			if((tabFolder.getStyle() & SWT.TOP) != 0) {
 				if(event.y > clientArea.y)
 					return;
 			} else {
 				if(event.y < clientArea.y + clientArea.height)
 					return;
 			}
 			doZoom();
 		}

 		public void mouseDown(MouseEvent e) {
 			EditorPane visibleEditor = getVisibleEditor();
 			if (visibleEditor != null) {
 				// switch to the editor
 				CTabItem item = getTab(visibleEditor);
 				visibleEditor.setFocus();
 				Rectangle bounds = item.getBounds();
 				if (bounds.contains(e.x, e.y)) {
 					if ((e.button == 1) && overImage(item, e.x))
 						visibleEditor.showPaneMenu();
 				}
 			}
 		}
 	});

 	// Listen for popup menu mouse event
 	tabFolder.addListener(SWT.MenuDetect, new Listener() {
 		public void handleEvent(Event event) {
 			EditorPane visibleEditor = getVisibleEditor();
 			if (event.type == SWT.MenuDetect && visibleEditor != null) {
 				CTabItem item = getTab(visibleEditor);
 				visibleEditor.setFocus();
 				Rectangle bounds = item.getBounds();
 				Point pt = tabFolder.toControl(event.x, event.y);
 				if (bounds.contains(pt.x, pt.y)) {
 					visibleEditor.showPaneMenu(tabFolder, new Point(event.x, event.y));
 				}
 			}
 		}
 	});

 	// register the interested mouse down listener
 	if (!mouseDownListenerAdded && getEditorArea() != null) {
 		tabFolder.addListener(SWT.MouseDown, getEditorArea().getMouseDownListener());
 		mouseDownListenerAdded = true;
 	}

 	// Create the pulldown menu on the CTabFolder
 	editorList = new EditorList(getEditorArea().getWorkbenchWindow(), this);
 	pullDownBar = new ToolBar(tabFolder, SWT.FLAT);
 	pullDownButton = new ToolItem(pullDownBar, SWT.PUSH);
 //	Image image = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_LCL_VIEW_MENU);
 	Image hotImage = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_LCL_VIEW_MENU_HOVER);
 	pullDownButton.setDisabledImage(hotImage);
 	pullDownButton.setImage(hotImage);
 //	pullDownButton.setHotImage(hotImage);
 	pullDownButton.setToolTipText(WorkbenchMessages.getString("EditorList.button.toolTip")); //$NON-NLS-1$

 	pullDownButton.addSelectionListener(new SelectionListener() {
 		public void widgetSelected(SelectionEvent e) {
 			openEditorList();

 		}
 		public void widgetDefaultSelected(SelectionEvent e) {
 		}
 	});

 	// Present the editorList pull-down if requested
 	if (usePulldown) {
 		tabFolder.setTopRight(pullDownBar);
 		pullDownBar.setVisible(true);
 	} else {
 		pullDownBar.setVisible(false);
 		tabFolder.setTopRight(null);
 	}

 	// Set the tab width
 	tabFolder.MIN_TAB_WIDTH = preferenceStore.getInt(IPreferenceConstants.EDITOR_TAB_WIDTH);
 }

 /**
  * Returns the tab for a part.
  */
 private CTabItem getTab(LayoutPart child) {
 	Iterator tabs = mapTabToEditor.keySet().iterator();
 	while (tabs.hasNext()) {
 		CTabItem tab = (CTabItem) tabs.next();
 		if (mapTabToEditor.get(tab) == child)
 			return tab;
 	}

 	return null;
 }

 public boolean isDragAllowed(EditorPane pane, Point p) {
 	CTabItem tab = getTab(pane);
 	return tab != null && overImage(tab, p.x);
 }

 /**
  * Returns true if <code>x</code> is over the label image.
  */
 private boolean overImage(CTabItem item, int x) {
 	if (item.getImage() == null) {
 		return false;
 	} else {
 		Rectangle imageBounds = item.getImage().getBounds();
 		return x < (item.getBounds().x + imageBounds.x + imageBounds.width);
 	}
 }

 private void closeEditorList() {
 	editorList.destroyControl();
 }

 public void openEditorList() {
 	// don't think this check is necessary, need to verify
 	if (listComposite != null) {
 		return;
 	}
 	Shell parent = getEditorArea().getWorkbenchWindow().getShell();

 	listComposite = new ViewForm(parent, SWT.BORDER);
 	listComposite.setVisible(false);
 	listComposite.addDisposeListener(new DisposeListener() {
 		public void widgetDisposed(DisposeEvent e) {
 			listComposite = null;
 		}
 	});
 	parent.addControlListener(new ControlAdapter() {
 		public void controlResized(ControlEvent e) {
 			if (listComposite != null) {
 				closeEditorList();
 			}
 		}
 	});

 	Control editorListControl = editorList.createControl(listComposite);
 	editorListControl.setVisible(false);
 	Table editorsTable = ((Table)editorListControl);
 	TableItem[] items = editorsTable.getItems();
 	if (items.length == 0) {
 		listComposite.dispose();
 		return;
 	}

 	listComposite.setContent(editorListControl);
 	listComposite.pack();

 	setEditorListBounds(parent);

 	listComposite.setVisible(true);
 	listComposite.moveAbove(null);
 	editorListControl.setVisible(true);
 	editorListControl.setFocus();
 	editorsTable.showSelection();

 	editorListControl.addListener(SWT.Deactivate, new Listener() {
 		public void handleEvent(Event event) {
 			if (listComposite != null) {
 				closeEditorList();
 			}
 		}
 	});
 }

 private void setEditorListBounds(Shell parent) {
 	final int MAX_ITEMS = 20;

 	Rectangle r = listComposite.getBounds();

 	int width = r.width;
 	int height = Math.min(r.height, MAX_ITEMS * ((Table)editorList.getControl()).getItemHeight());
 	Rectangle bounds = tabFolder.getClientArea();
 	Point point = new Point(bounds.x + bounds.width - width, bounds.y);
 	if (tabLocation == SWT.BOTTOM) {
 		point.y = bounds.y + bounds.height - height - 1;
 	}
 	point = tabFolder.toDisplay(point);
 	point = parent.toControl(point);
 	listComposite.setBounds(listComposite.computeTrim(point.x, point.y, width, height));
 }

 public void resizeEditorList() {
 	Shell parent = getEditorArea().getWorkbenchWindow().getShell();
 	listComposite.pack();
 	setEditorListBounds(parent);
 }


 public void showPaneMenu() {
 	EditorPane visibleEditor = getVisibleEditor();
 	if (visibleEditor != null) {
 		CTabItem item = getTab(visibleEditor);
 		Rectangle bounds = item.getBounds();
 		visibleEditor.showPaneMenu(tabFolder,tabFolder.toDisplay(new Point(bounds.x, bounds.height)));
 	}
 }

 protected void checkEnableDrag() {
 	// When first editor added, also enable workbook for
 	// D&D - this avoids dragging the initial empty workbook
 	if (tabFolder != null && tabFolder.getItemCount() == 1)
 		enableDrag(this);
 }

 protected void disposePresentation() {
 	// dispose of disabled images
 	for(int i = 0; i < tabFolder.getItemCount(); i++) {
 		CTabItem tab = tabFolder.getItem(i);
 		if (tab.getDisabledImage() != null)
 			tab.getDisabledImage().dispose();
 	}

 	tabFolder.dispose();
 	tabFolder = null;
 	mouseDownListenerAdded = false;

 	mapTabToEditor.clear();
 }

 protected void drawGradient(Color fgColor, Color[] bgColors, int[] bgPercents) {
 	tabFolder.setSelectionForeground(fgColor);
 	tabFolder.setSelectionBackground(bgColors, bgPercents);
 	tabFolder.update();
 }

 // getMinimumHeight() added by cagatayk@acm.org
 /**
  * @see LayoutPart#getMinimumHeight()
  */
 public int getMinimumHeight() {
 	if (tabFolder != null && !tabFolder.isDisposed() && getItemCount() > 0)
 		/* Subtract 1 for divider line, bottom border is enough
 		 * for editor tabs.
 		 */
 		return tabFolder.computeTrim(0, 0, 0, 0).height - 1;
  	else
  		return super.getMinimumHeight();
 }

 public Control getControl() {
 	return tabFolder;
 }

 public Control[] getTabList() {
 	if (tabFolder == null) {
 		return new Control[0];
 	}
 	EditorPane visibleEditor = getVisibleEditor();
 	if (visibleEditor == null) {
 		return new Control[] { tabFolder };
 	}
 	if ((tabFolder.getStyle() & SWT.TOP) != 0) {
 		return new Control[] { tabFolder, visibleEditor.getControl() };
 	}
 	else {
 		return new Control[] { visibleEditor.getControl(), tabFolder };
 	}
 }

 public void showVisibleEditor() {
 	if (tabFolder != null) {
 		tabFolder.showSelection();
 	}
 }

 protected void disposeItem(EditorPane editorPane) {
 	removeTab(getTab(editorPane));
 	if (tabFolder.getItemCount() == 0) {
 		pullDownBar.setVisible(false);
 	}
 }

 /**
  * Remove the tab item from the tab folder
  */
 private void removeTab(CTabItem tab) {
 	if (tabFolder != null) {
 		if (tab != null) {
 			mapTabToEditor.remove(tab);
 			if (tab.getDisabledImage() != null)
 				tab.getDisabledImage().dispose();
 			// Note, that disposing of the tab causes the
 			// tab folder to select another tab and fires
 			// a selection event. In this situation, do
 			// not assign focus.
 			assignFocusOnSelection = false;
 			tab.dispose();
 			assignFocusOnSelection = true;
 		}
 	}
 }

 public void setContainer(ILayoutContainer container) {
 	super.setContainer(container);
 	// register the interested mouse down listener
 	if (!mouseDownListenerAdded && getEditorArea() != null && tabFolder != null) {
 		tabFolder.addListener(SWT.MouseDown, getEditorArea().getMouseDownListener());
 		mouseDownListenerAdded = true;
 	}
 }

 protected void setVisibleItem(EditorPane editorPane) {
 	CTabItem key = getTab(editorPane);
 	if (key != null) {
 		int index = tabFolder.indexOf(key);
 		tabFolder.setSelection(index);
 	}
 }

 public void tabFocusHide() {
 	if (!ignoreTabFocusHide) {
 		super.tabFocusHide();
 	}
 }

 protected void updateItem(EditorPane editorPane) {
 	// Get tab.
 	CTabItem tab = getTab(editorPane);
 	if(tab == null) return;

 	IEditorReference ref = editorPane.getEditorReference();

 	// Update title.
 	String title = ref.getTitle();
 	if (ref.isDirty())
 		title = "*" + title; //$NON-NLS-1$
 	tab.setText(title);

 	boolean useColorIcons = ActionContributionItem.getUseColorIconsInToolbars();

 	Image image = ref.getTitleImage();
 	// Update the tab image
 	if (image == null || image.isDisposed()) {
 		// Normal image.
 		tab.setImage(null);
 		// Disabled image.
 		if (!useColorIcons) {
 			Image disableImage = tab.getDisabledImage();
 			if (disableImage != null) {
 				disableImage.dispose();
 				tab.setDisabledImage(null);
 			}
 		}
 	} else if (!image.equals(tab.getImage())) {
 		// Normal image.
 		tab.setImage(image);
 		// Disabled image.
 		if (!useColorIcons) {
 			Image disableImage = tab.getDisabledImage();
 			if (disableImage != null)
 				disableImage.dispose();
 			disableImage = new Image(tab.getDisplay(), image, SWT.IMAGE_DISABLE);
 			tab.setDisabledImage(disableImage);
 		}
 	}

 	// Tool tip.
 	String toolTip = ref.getTitleToolTip();
 	tab.setToolTipText(toolTip);
 	tab.getParent().update();
 }

 protected void disposeAllItems() {
 	// turn off tab selection handling so as
 	// not to activate another editor when a
 	// tab is disposed. See PR 1GBXAWZ
 	handleTabSelection = false;

 	Iterator tabs = mapTabToEditor.keySet().iterator();
 	while (tabs.hasNext()) {
 		CTabItem tab = (CTabItem) tabs.next();
 		if (tab.getDisabledImage() != null)
 			tab.getDisabledImage().dispose();
 		tab.dispose();
 	}
 	// disable the pulldown menu
 	pullDownBar.setVisible(false);

 	// Clean up
 	mapTabToEditor.clear();
 	handleTabSelection = true;
 }

 public void reorderTab(EditorPane pane, int x, int y) {
 	CTabItem sourceTab = getTab(pane);
 	if (sourceTab == null)
 		return;

 	// adjust the y coordinate to fall within the tab area
 	Point location = new Point(1, 1);
 	if ((tabFolder.getStyle() & SWT.BOTTOM) != 0)
 		location.y = tabFolder.getSize().y - 4; // account for 3 pixel border

 	// adjust the x coordinate to be within the tab area
 	if (x > location.x)
 		location.x = x;

 	// find the tab under the adjusted location.
 	CTabItem targetTab = tabFolder.getItem(location);

 	// no tab under location so move editor's tab to end
 	if (targetTab == null) {
 		// do nothing if already at the end
 		if (tabFolder.indexOf(sourceTab) != tabFolder.getItemCount() - 1)
 			reorderTab(pane, sourceTab, -1);

 		return;
 	}

 	// do nothing if over editor's own tab
 	if (targetTab == sourceTab)
 		return;

 	// do nothing if already before target tab
 	int sourceIndex = tabFolder.indexOf(sourceTab);
 	int targetIndex = tabFolder.indexOf(targetTab);

 	if (sourceIndex == targetIndex - 1)
 		return;

 	//Source is going to be dispose so the target index will change.
 	if (sourceIndex < targetIndex)
 		targetIndex--;

 	reorderTab(pane, sourceTab, targetIndex);
 }
 /**
  * Move the specified editor to the a new position.
  * Move to the end if <code>newIndex</code> is less then
  * zero.
  */
 public void reorderTab(EditorPane pane, int newIndex) {
 	reorderTab(pane, getTab(pane), newIndex);
 }

 /**
  * Reorder the tab representing the specified pane.
  */
 private void reorderTab(EditorPane pane, CTabItem sourceTab, int newIndex) {
 	int oldIndex = tabFolder.indexOf(sourceTab);
 	if(newIndex < 0)
 		if(oldIndex == tabFolder.getItemCount() - 1)
 			return;
 	else if(oldIndex == newIndex)
 		return;

 	// remember if the source tab was the visible one
 	boolean wasVisible = (tabFolder.getSelection() == sourceTab);

 	// Remove old tab.
 	disableDrag(pane);
 	removeTab(sourceTab);

 	// Create the new tab at the specified index
 	CTabItem newTab;
 	if (newIndex < 0)
 		newTab = createTab(pane);
 	else
 		newTab = createTab(pane, newIndex);
 	CTabPartDragDrop partDragDrop = (CTabPartDragDrop) getDragSource(pane);
 	partDragDrop.setTab(newTab);

 	// update order of editors.

 	List editors = getEditorList();
 	editors.remove(pane);
 	if (newIndex < 0)
 		editors.add(pane);
 	else
 		editors.add(newIndex, pane);

 	// update the new tab's visibility but do
 	// not set focus...caller's responsibility.
 	// Note, if the pane already had focus, it
 	// will still have it after the tab order change.
 	if (wasVisible) {
 		tabFolder.setSelection(newTab);
 		setVisibleEditor(pane);
 	}
 }

 /* (non-Javadoc)
  * @see org.eclipse.ui.internal.EditorWorkbook#createDragSource(org.eclipse.ui.internal.EditorPane)
  */
 protected PartDragDrop createDragSource(LayoutPart part) {
 	if (part instanceof EditorPane) {
 		CTabItem tab = getTab(part);
 		if (tab != null) {
 			return new CTabPartDragDrop(part, this.tabFolder, tab);
 		}
 	}
 	else if (part instanceof EditorWorkbook) {
 		return new CTabPartDragDrop(part, this.tabFolder, null);
 	}
 	return null;
 }

 }
	/*******************************************************************************
	* Copyright (c) 2000, 2003 IBM Corporation and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Common Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/cpl-v10.html
	*
	* Contributors:
	* IBM Corporation - initial API and implementation
	*******************************************************************************/

	package org.eclipse.ui.internal;

	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import org.eclipse.swt.SWT;
	import org.eclipse.swt.custom.CTabFolder;
	import org.eclipse.swt.custom.CTabFolderAdapter;
	import org.eclipse.swt.custom.CTabFolderEvent;
	import org.eclipse.swt.custom.CTabItem;
	import org.eclipse.swt.custom.ViewForm;
	import org.eclipse.swt.events.ControlAdapter;
	import org.eclipse.swt.events.ControlEvent;
	import org.eclipse.swt.events.DisposeEvent;
	import org.eclipse.swt.events.DisposeListener;
	import org.eclipse.swt.events.MouseAdapter;
	import org.eclipse.swt.events.MouseEvent;
	import org.eclipse.swt.events.SelectionAdapter;
	import org.eclipse.swt.events.SelectionEvent;
	import org.eclipse.swt.events.SelectionListener;
	import org.eclipse.swt.graphics.Color;
	import org.eclipse.swt.graphics.Image;
	import org.eclipse.swt.graphics.Point;
	import org.eclipse.swt.graphics.Rectangle;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Control;
	import org.eclipse.swt.widgets.Event;
	import org.eclipse.swt.widgets.Listener;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.swt.widgets.Table;
	import org.eclipse.swt.widgets.TableItem;
	import org.eclipse.swt.widgets.ToolBar;
	import org.eclipse.swt.widgets.ToolItem;

	import org.eclipse.jface.action.ActionContributionItem;
	import org.eclipse.jface.preference.IPreferenceStore;

	import org.eclipse.ui.IEditorReference;

	public class TabbedEditorWorkbook extends EditorWorkbook {

	private IPreferenceStore preferenceStore = WorkbenchPlugin.getDefault().getPreferenceStore();
	private int tabLocation = -1; // Initialized in constructor.
	private CTabFolder tabFolder;
	private Map mapTabToEditor = new HashMap();
	private ToolBar pullDownBar;
	private ToolItem pullDownButton;
	private EditorList editorList;
	private ViewForm listComposite;
	private boolean assignFocusOnSelection = true;
	private boolean ignoreTabFocusHide = false;
	private boolean handleTabSelection = true;
	private boolean mouseDownListenerAdded = false;
	private boolean usePulldown = false;


	public TabbedEditorWorkbook(EditorArea editorArea) {
	super(editorArea);

	// Get tab location preference.
	if (tabLocation == -1)
	tabLocation =
	preferenceStore.getInt(
	IPreferenceConstants.EDITOR_TAB_POSITION);
	}

	protected Object createItem(EditorPane editorPane) {
	return createTab(editorPane);
	}

	/**
	* Create a new tab for an item.
	*/
	private CTabItem createTab(EditorPane editorPane) {
	return createTab(editorPane, tabFolder.getItemCount());
	}

	/**
	* Create a new tab for an item at a particular index.
	*/
	private CTabItem createTab(EditorPane editorPane, int index) {
	CTabItem tab = new CTabItem(tabFolder, SWT.NONE, index);
	mapTabToEditor.put(tab, editorPane);
	enableDrag(editorPane);
	updateEditorTab((IEditorReference) editorPane.getPartReference());
	if (tabFolder.getItemCount() == 1) {
	if (tabFolder.getTopRight() != null) {
	pullDownBar.setVisible(true);
	}
	}
	return tab;
	}

	protected void setControlSize() {
	EditorPane visibleEditor = getVisibleEditor();
	if (visibleEditor == null \|\| getControl() == null)
	return;
	Rectangle bounds = PartTabFolder.calculatePageBounds(tabFolder);
	visibleEditor.setBounds(bounds);
	visibleEditor.moveAbove(tabFolder);
	}

	protected void createPresentation(Composite parent) {
	usePulldown = preferenceStore.getBoolean(IPreferenceConstants.EDITORLIST_PULLDOWN_ACTIVE);

	tabFolder = new CTabFolder(parent, SWT.BORDER \| tabLocation);

	// prevent close button and scroll buttons from taking focus
	tabFolder.setTabList(new Control[0]);

	// redirect drop request to the workbook
	tabFolder.setData(this);

	// listener to close the editor
	tabFolder.addCTabFolderListener(new CTabFolderAdapter() {
	public void itemClosed(CTabFolderEvent e) {
	e.doit = false; // otherwise tab is auto disposed on return
	EditorPane pane = (EditorPane) mapTabToEditor.get(e.item);
	pane.doHide();
	}
	});

	// listener to switch between visible tabItems
	tabFolder.addSelectionListener(new SelectionAdapter() {
	public void widgetSelected(SelectionEvent e) {
	if (handleTabSelection) {
	EditorPane pane = (EditorPane) mapTabToEditor.get(e.item);
	// Pane can be null when tab is just created but not map yet.
	if (pane != null) {
	setVisibleEditor(pane);
	if (assignFocusOnSelection) {
	// If we get a tab focus hide request, it's from
	// the previous editor in this workbook which had focus.
	// Therefore ignore it to avoid paint flicker
	ignoreTabFocusHide = true;
	pane.setFocus();
	ignoreTabFocusHide = false;
	}
	}
	}
	}
	});

	// listener to resize visible components
	tabFolder.addListener(SWT.Resize, new Listener() {
	public void handleEvent(Event e) {
	setControlSize();
	}
	});

	// listen for mouse down on tab area to set focus.
	tabFolder.addMouseListener(new MouseAdapter() {
	public void mouseDoubleClick(MouseEvent event) {
	Rectangle clientArea = tabFolder.getClientArea();
	if((tabFolder.getStyle() & SWT.TOP) != 0) {
	if(event.y > clientArea.y)
	return;
	} else {
	if(event.y < clientArea.y + clientArea.height)
	return;
	}
	doZoom();
	}

	public void mouseDown(MouseEvent e) {
	EditorPane visibleEditor = getVisibleEditor();
	if (visibleEditor != null) {
	// switch to the editor
	CTabItem item = getTab(visibleEditor);
	visibleEditor.setFocus();
	Rectangle bounds = item.getBounds();
	if (bounds.contains(e.x, e.y)) {
	if ((e.button == 1) && overImage(item, e.x))
	visibleEditor.showPaneMenu();
	}
	}
	}
	});

	// Listen for popup menu mouse event
	tabFolder.addListener(SWT.MenuDetect, new Listener() {
	public void handleEvent(Event event) {
	EditorPane visibleEditor = getVisibleEditor();
	if (event.type == SWT.MenuDetect && visibleEditor != null) {
	CTabItem item = getTab(visibleEditor);
	visibleEditor.setFocus();
	Rectangle bounds = item.getBounds();
	Point pt = tabFolder.toControl(event.x, event.y);
	if (bounds.contains(pt.x, pt.y)) {
	visibleEditor.showPaneMenu(tabFolder, new Point(event.x, event.y));
	}
	}
	}
	});

	// register the interested mouse down listener
	if (!mouseDownListenerAdded && getEditorArea() != null) {
	tabFolder.addListener(SWT.MouseDown, getEditorArea().getMouseDownListener());
	mouseDownListenerAdded = true;
	}

	// Create the pulldown menu on the CTabFolder
	editorList = new EditorList(getEditorArea().getWorkbenchWindow(), this);
	pullDownBar = new ToolBar(tabFolder, SWT.FLAT);
	pullDownButton = new ToolItem(pullDownBar, SWT.PUSH);
	// Image image = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_LCL_VIEW_MENU);
	Image hotImage = WorkbenchImages.getImage(IWorkbenchGraphicConstants.IMG_LCL_VIEW_MENU_HOVER);
	pullDownButton.setDisabledImage(hotImage);
	pullDownButton.setImage(hotImage);
	// pullDownButton.setHotImage(hotImage);
	pullDownButton.setToolTipText(WorkbenchMessages.getString("EditorList.button.toolTip")); //$NON-NLS-1$

	pullDownButton.addSelectionListener(new SelectionListener() {
	public void widgetSelected(SelectionEvent e) {
	openEditorList();

	}
	public void widgetDefaultSelected(SelectionEvent e) {
	}
	});

	// Present the editorList pull-down if requested
	if (usePulldown) {
	tabFolder.setTopRight(pullDownBar);
	pullDownBar.setVisible(true);
	} else {
	pullDownBar.setVisible(false);
	tabFolder.setTopRight(null);
	}

	// Set the tab width
	tabFolder.MIN_TAB_WIDTH = preferenceStore.getInt(IPreferenceConstants.EDITOR_TAB_WIDTH);
	}

	/**
	* Returns the tab for a part.
	*/
	private CTabItem getTab(LayoutPart child) {
	Iterator tabs = mapTabToEditor.keySet().iterator();
	while (tabs.hasNext()) {
	CTabItem tab = (CTabItem) tabs.next();
	if (mapTabToEditor.get(tab) == child)
	return tab;
	}

	return null;
	}

	public boolean isDragAllowed(EditorPane pane, Point p) {
	CTabItem tab = getTab(pane);
	return tab != null && overImage(tab, p.x);
	}

	/**
	* Returns true if <code>x</code> is over the label image.
	*/
	private boolean overImage(CTabItem item, int x) {
	if (item.getImage() == null) {
	return false;
	} else {
	Rectangle imageBounds = item.getImage().getBounds();
	return x < (item.getBounds().x + imageBounds.x + imageBounds.width);
	}
	}

	private void closeEditorList() {
	editorList.destroyControl();
	}

	public void openEditorList() {
	// don't think this check is necessary, need to verify
	if (listComposite != null) {
	return;
	}
	Shell parent = getEditorArea().getWorkbenchWindow().getShell();

	listComposite = new ViewForm(parent, SWT.BORDER);
	listComposite.setVisible(false);
	listComposite.addDisposeListener(new DisposeListener() {
	public void widgetDisposed(DisposeEvent e) {
	listComposite = null;
	}
	});
	parent.addControlListener(new ControlAdapter() {
	public void controlResized(ControlEvent e) {
	if (listComposite != null) {
	closeEditorList();
	}
	}
	});

	Control editorListControl = editorList.createControl(listComposite);
	editorListControl.setVisible(false);
	Table editorsTable = ((Table)editorListControl);
	TableItem[] items = editorsTable.getItems();
	if (items.length == 0) {
	listComposite.dispose();
	return;
	}

	listComposite.setContent(editorListControl);
	listComposite.pack();

	setEditorListBounds(parent);

	listComposite.setVisible(true);
	listComposite.moveAbove(null);
	editorListControl.setVisible(true);
	editorListControl.setFocus();
	editorsTable.showSelection();

	editorListControl.addListener(SWT.Deactivate, new Listener() {
	public void handleEvent(Event event) {
	if (listComposite != null) {
	closeEditorList();
	}
	}
	});
	}

	private void setEditorListBounds(Shell parent) {
	final int MAX_ITEMS = 20;

	Rectangle r = listComposite.getBounds();

	int width = r.width;
	int height = Math.min(r.height, MAX_ITEMS * ((Table)editorList.getControl()).getItemHeight());
	Rectangle bounds = tabFolder.getClientArea();
	Point point = new Point(bounds.x + bounds.width - width, bounds.y);
	if (tabLocation == SWT.BOTTOM) {
	point.y = bounds.y + bounds.height - height - 1;
	}
	point = tabFolder.toDisplay(point);
	point = parent.toControl(point);
	listComposite.setBounds(listComposite.computeTrim(point.x, point.y, width, height));
	}

	public void resizeEditorList() {
	Shell parent = getEditorArea().getWorkbenchWindow().getShell();
	listComposite.pack();
	setEditorListBounds(parent);
	}


	public void showPaneMenu() {
	EditorPane visibleEditor = getVisibleEditor();
	if (visibleEditor != null) {
	CTabItem item = getTab(visibleEditor);
	Rectangle bounds = item.getBounds();
	visibleEditor.showPaneMenu(tabFolder,tabFolder.toDisplay(new Point(bounds.x, bounds.height)));
	}
	}

	protected void checkEnableDrag() {
	// When first editor added, also enable workbook for
	// D&D - this avoids dragging the initial empty workbook
	if (tabFolder != null && tabFolder.getItemCount() == 1)
	enableDrag(this);
	}

	protected void disposePresentation() {
	// dispose of disabled images
	for(int i = 0; i < tabFolder.getItemCount(); i++) {
	CTabItem tab = tabFolder.getItem(i);
	if (tab.getDisabledImage() != null)
	tab.getDisabledImage().dispose();
	}

	tabFolder.dispose();
	tabFolder = null;
	mouseDownListenerAdded = false;

	mapTabToEditor.clear();
	}

	protected void drawGradient(Color fgColor, Color[] bgColors, int[] bgPercents) {
	tabFolder.setSelectionForeground(fgColor);
	tabFolder.setSelectionBackground(bgColors, bgPercents);
	tabFolder.update();
	}

	// getMinimumHeight() added by cagatayk@acm.org
	/**
	* @see LayoutPart#getMinimumHeight()
	*/
	public int getMinimumHeight() {
	if (tabFolder != null && !tabFolder.isDisposed() && getItemCount() > 0)
	/* Subtract 1 for divider line, bottom border is enough
	* for editor tabs.
	*/
	return tabFolder.computeTrim(0, 0, 0, 0).height - 1;
	else
	return super.getMinimumHeight();
	}

	public Control getControl() {
	return tabFolder;
	}

	public Control[] getTabList() {
	if (tabFolder == null) {
	return new Control[0];
	}
	EditorPane visibleEditor = getVisibleEditor();
	if (visibleEditor == null) {
	return new Control[] { tabFolder };
	}
	if ((tabFolder.getStyle() & SWT.TOP) != 0) {
	return new Control[] { tabFolder, visibleEditor.getControl() };
	}
	else {
	return new Control[] { visibleEditor.getControl(), tabFolder };
	}
	}

	public void showVisibleEditor() {
	if (tabFolder != null) {
	tabFolder.showSelection();
	}
	}

	protected void disposeItem(EditorPane editorPane) {
	removeTab(getTab(editorPane));
	if (tabFolder.getItemCount() == 0) {
	pullDownBar.setVisible(false);
	}
	}

	/**
	* Remove the tab item from the tab folder
	*/
	private void removeTab(CTabItem tab) {
	if (tabFolder != null) {
	if (tab != null) {
	mapTabToEditor.remove(tab);
	if (tab.getDisabledImage() != null)
	tab.getDisabledImage().dispose();
	// Note, that disposing of the tab causes the
	// tab folder to select another tab and fires
	// a selection event. In this situation, do
	// not assign focus.
	assignFocusOnSelection = false;
	tab.dispose();
	assignFocusOnSelection = true;
	}
	}
	}

	public void setContainer(ILayoutContainer container) {
	super.setContainer(container);
	// register the interested mouse down listener
	if (!mouseDownListenerAdded && getEditorArea() != null && tabFolder != null) {
	tabFolder.addListener(SWT.MouseDown, getEditorArea().getMouseDownListener());
	mouseDownListenerAdded = true;
	}
	}

	protected void setVisibleItem(EditorPane editorPane) {
	CTabItem key = getTab(editorPane);
	if (key != null) {
	int index = tabFolder.indexOf(key);
	tabFolder.setSelection(index);
	}
	}

	public void tabFocusHide() {
	if (!ignoreTabFocusHide) {
	super.tabFocusHide();
	}
	}

	protected void updateItem(EditorPane editorPane) {
	// Get tab.
	CTabItem tab = getTab(editorPane);
	if(tab == null) return;

	IEditorReference ref = editorPane.getEditorReference();

	// Update title.
	String title = ref.getTitle();
	if (ref.isDirty())
	title = "*" + title; //$NON-NLS-1$
	tab.setText(title);

	boolean useColorIcons = ActionContributionItem.getUseColorIconsInToolbars();

	Image image = ref.getTitleImage();
	// Update the tab image
	if (image == null \|\| image.isDisposed()) {
	// Normal image.
	tab.setImage(null);
	// Disabled image.
	if (!useColorIcons) {
	Image disableImage = tab.getDisabledImage();
	if (disableImage != null) {
	disableImage.dispose();
	tab.setDisabledImage(null);
	}
	}
	} else if (!image.equals(tab.getImage())) {
	// Normal image.
	tab.setImage(image);
	// Disabled image.
	if (!useColorIcons) {
	Image disableImage = tab.getDisabledImage();
	if (disableImage != null)
	disableImage.dispose();
	disableImage = new Image(tab.getDisplay(), image, SWT.IMAGE_DISABLE);
	tab.setDisabledImage(disableImage);
	}
	}

	// Tool tip.
	String toolTip = ref.getTitleToolTip();
	tab.setToolTipText(toolTip);
	tab.getParent().update();
	}

	protected void disposeAllItems() {
	// turn off tab selection handling so as
	// not to activate another editor when a
	// tab is disposed. See PR 1GBXAWZ
	handleTabSelection = false;

	Iterator tabs = mapTabToEditor.keySet().iterator();
	while (tabs.hasNext()) {
	CTabItem tab = (CTabItem) tabs.next();
	if (tab.getDisabledImage() != null)
	tab.getDisabledImage().dispose();
	tab.dispose();
	}
	// disable the pulldown menu
	pullDownBar.setVisible(false);

	// Clean up
	mapTabToEditor.clear();
	handleTabSelection = true;
	}

	public void reorderTab(EditorPane pane, int x, int y) {
	CTabItem sourceTab = getTab(pane);
	if (sourceTab == null)
	return;

	// adjust the y coordinate to fall within the tab area
	Point location = new Point(1, 1);
	if ((tabFolder.getStyle() & SWT.BOTTOM) != 0)
	location.y = tabFolder.getSize().y - 4; // account for 3 pixel border

	// adjust the x coordinate to be within the tab area
	if (x > location.x)
	location.x = x;

	// find the tab under the adjusted location.
	CTabItem targetTab = tabFolder.getItem(location);

	// no tab under location so move editor's tab to end
	if (targetTab == null) {
	// do nothing if already at the end
	if (tabFolder.indexOf(sourceTab) != tabFolder.getItemCount() - 1)
	reorderTab(pane, sourceTab, -1);

	return;
	}

	// do nothing if over editor's own tab
	if (targetTab == sourceTab)
	return;

	// do nothing if already before target tab
	int sourceIndex = tabFolder.indexOf(sourceTab);
	int targetIndex = tabFolder.indexOf(targetTab);

	if (sourceIndex == targetIndex - 1)
	return;

	//Source is going to be dispose so the target index will change.
	if (sourceIndex < targetIndex)
	targetIndex--;

	reorderTab(pane, sourceTab, targetIndex);
	}
	/**
	* Move the specified editor to the a new position.
	* Move to the end if <code>newIndex</code> is less then
	* zero.
	*/
	public void reorderTab(EditorPane pane, int newIndex) {
	reorderTab(pane, getTab(pane), newIndex);
	}

	/**
	* Reorder the tab representing the specified pane.
	*/
	private void reorderTab(EditorPane pane, CTabItem sourceTab, int newIndex) {
	int oldIndex = tabFolder.indexOf(sourceTab);
	if(newIndex < 0)
	if(oldIndex == tabFolder.getItemCount() - 1)
	return;
	else if(oldIndex == newIndex)
	return;

	// remember if the source tab was the visible one
	boolean wasVisible = (tabFolder.getSelection() == sourceTab);

	// Remove old tab.
	disableDrag(pane);
	removeTab(sourceTab);

	// Create the new tab at the specified index
	CTabItem newTab;
	if (newIndex < 0)
	newTab = createTab(pane);
	else
	newTab = createTab(pane, newIndex);
	CTabPartDragDrop partDragDrop = (CTabPartDragDrop) getDragSource(pane);
	partDragDrop.setTab(newTab);

	// update order of editors.

	List editors = getEditorList();
	editors.remove(pane);
	if (newIndex < 0)
	editors.add(pane);
	else
	editors.add(newIndex, pane);

	// update the new tab's visibility but do
	// not set focus...caller's responsibility.
	// Note, if the pane already had focus, it
	// will still have it after the tab order change.
	if (wasVisible) {
	tabFolder.setSelection(newTab);
	setVisibleEditor(pane);
	}
	}

	/* (non-Javadoc)
	* @see org.eclipse.ui.internal.EditorWorkbook#createDragSource(org.eclipse.ui.internal.EditorPane)
	*/
	protected PartDragDrop createDragSource(LayoutPart part) {
	if (part instanceof EditorPane) {
	CTabItem tab = getTab(part);
	if (tab != null) {
	return new CTabPartDragDrop(part, this.tabFolder, tab);
	}
	}
	else if (part instanceof EditorWorkbook) {
	return new CTabPartDragDrop(part, this.tabFolder, null);
	}
	return null;
	}

	}