package org.eclipse.ui.part;

/*
 * (c) Copyright IBM Corp. 2000, 2001.
 * All Rights Reserved.
 */
 
import java.util.ArrayList;
import java.util.Iterator;

import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.CTabFolder;
import org.eclipse.swt.custom.CTabItem;
import org.eclipse.swt.events.*;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.*;

import org.eclipse.jface.util.Assert;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.ui.*;

/**
 * A multi-page editor is an editor with multiple pages, each of which may
 * contain an editor or an arbitrary SWT control.
 * <p>
 * Subclasses must implement the following methods:
 * <ul>
 *   <li><code>createPages</code> - to create the required pages by calling one
 *     of the <code>addPage</code> methods</li>
 *   <li><code>IEditorPart.doSave</code> - to save contents of editor</li>
 *   <li><code>IEditorPart.doSaveAs</code> - to save contents of editor</li>
 *   <li><code>IEditorPart.isSaveAsAllowed</code> - to enable Save As</li>
 *   <li><code>IEditorPart.gotoMarker</code> - to scroll to a marker</li>
 * </ul>
 * </p>
 * <p>
 * Multi-page editors have a single action bar contributor, which manages 
 * contributions for all the pages. The contributor must be a subclass of
 * <code>AbstractMultiPageEditorActionBarContributor</code>.
 * Note that since any nested editors are created directly in code by callers of 
 * <code>addPage(IEditorPart,IEditorInput)</code>, nested editors do not have 
 * their own contributors.
 * </p>
 *
 * @see AbstractMultiPageEditorActionBarContributor
 */
public abstract class MultiPageEditorPart extends EditorPart {
	/**
	 * The container widget.
	 */
	private CTabFolder container;

	/**
	 * List of nested editors. Element type: IEditorPart.
	 * Need to hang onto them here, in addition to using get/setData on the items,
	 * because dispose() needs to access them, but widgetry has already been disposed at that point.
	 */
	private ArrayList nestedEditors = new ArrayList(3);
/**
 * Creates an empty multi-page editor with no pages.
 */
protected MultiPageEditorPart() {
	super();
}
/**
 * Creates and adds a new page containing the given control to this multi-page 
 * editor.  The control may be <code>null</code>, allowing it to be created
 * and set later using <code>setControl</code>.
 *
 * @param control the control, or <code>null</code>
 * @return the index of the new page
 *
 * @see #setControl
 */
public int addPage(Control control) {
	createItem(control);
	return getPageCount() - 1;
}
/**
 * Creates and adds a new page containing the given editor to this multi-page 
 * editor. This also hooks a property change listener on the nested editor.
 *
 * @param editor the nested editor
 * @param input the input for the nested editor
 * @return the index of the new page
 * @exception PartInitException if a new page could not be created
 *
 * @see #handlePropertyChange the handler for property change events from the nested editor
 */
public int addPage(IEditorPart editor, IEditorInput input) throws PartInitException {
	IEditorSite site = createSite(editor);
	// call init first so that if an exception is thrown, we have created no new widgets
	editor.init(site, input);
	Composite parent2 = new Composite(getContainer(), SWT.NONE);
	parent2.setLayout(new FillLayout());
	editor.createPartControl(parent2);
	editor.addPropertyListener(
		new IPropertyListener() {
			public void propertyChanged(Object source, int propertyId) {
				MultiPageEditorPart.this.handlePropertyChange(propertyId);
			}
		});
	// create item for page only after createPartControl has succeeded
	Item item = createItem(parent2);
	// remember the editor, as both data on the item, and in the list of editors (see field comment)
	item.setData(editor);
	nestedEditors.add(editor);
	return getPageCount() - 1;
}
/**
 * Creates an empty container.
 * Creates a CTabFolder with no style bits set, and hooks a selection 
 * listener which calls <code>pageChange()</code> whenever the selected tab changes.
 * 
 * @return a new container
 */
private CTabFolder createContainer(Composite parent) {
	final CTabFolder container = new CTabFolder(parent, SWT.BOTTOM);
	container.addSelectionListener(new SelectionAdapter() {
		public void widgetSelected(SelectionEvent e) {
			int newPageIndex = container.indexOf((CTabItem) e.item);
			pageChange(newPageIndex);
		}
	});
	container.addMouseListener(new MouseAdapter() {
		public void mouseDown(MouseEvent e) {
			container.setFocus();
		}
	});
	return container;
}
/**
 * Creates a tab item and places control in the new item.
 * The item is a CTabItem with no style bits set.
 *
 * @param control is the control to be placed in an item
 * @return a new item
 */
private CTabItem createItem(Control control) {
	CTabItem item = new CTabItem(getTabFolder(), SWT.NONE);
	item.setControl(control);
	return item;
}
/**
 * Creates the pages of this multi-page editor.
 * <p>
 * Subclasses must implement this method.
 * </p>
 */
protected abstract void createPages();
/**
 * The <code>MultiPageEditor</code> implementation of this 
 * <code>IWorkbenchPart</code> method creates the control for the multi-page
 * editor by calling <code>createContainer</code>, then <code>createPages</code>.
 * Subclasses should implement <code>createPages</code> rather than overriding 
 * this method.
 */
public final void createPartControl(Composite parent) {
	this.container = createContainer(parent);
	createPages();
	// set the active page (page 0 by default), unless it has already been done
	if (getTabFolder().getSelectionIndex() == -1)
		setActivePage(0);
}
/**
 * Creates the site for the given nested editor.
 * The <code>MultiPageEditorPart</code> implementation of this method creates an 
 * instance of <code>MultiPageEditorSite</code>. Subclasses may reimplement
 * to create more specialized sites.
 *
 * @param editor the nested editor
 * @return the editor site
 */
protected IEditorSite createSite(IEditorPart editor){
	return new MultiPageEditorSite(this, editor);
}
/**
 * The <code>MultiPageEditorPart</code> implementation of this 
 * <code>IWorkbenchPart</code> method disposes all nested editors.
 * Subclasses may extend.
 */
public void dispose() {
	for (int i = 0; i < nestedEditors.size(); ++i) {
		IEditorPart editor = (IEditorPart) nestedEditors.get(i);
		editor.dispose();
	}
	nestedEditors.clear();
}
/**
 * Returns the active nested editor if there is one.
 * <p>
 * Subclasses should not override this method
 * </p>
 * 
 * @return the active nested editor, or <code>null</code> if none
 */
protected IEditorPart getActiveEditor() {
	int index = getActivePage();
	if (index != -1)
		return getEditor(index);
	return null;
}
/**
 * Returns the index of the currently active page,
 * or -1 if there is no active page.
 * <p>
 * Subclasses should not override this method
 * </p>
 *
 * @return the index of the active page, or -1 if there is no active page
 */
protected int getActivePage() {
	// May not have been created yet.
	if (getTabFolder() != null)
		return getTabFolder().getSelectionIndex();
	return -1;
}
/**
 * Returns the composite control containing this multi-page editor's pages.
 * This should be used as the parent when creating controls for the individual pages.
 * That is, when calling <code>addPage(Control)</code>, the passed control should be
 * a child of this container.
 * <p>
 * Warning: Clients should not assume that the container is any particular subclass
 * of Composite.  The actual class used may change in order to improve the look and feel of
 * multi-page editors.  Any code making assumptions on the particular subclass would thus be broken.
 * </p>
 * <p>
 * Subclasses should not override this method
 * </p>
 *
 * @return the composite, or <code>null</code> if <code>createPartControl</code>
 *   has not been called yet
 */
protected Composite getContainer() {
	return container;
}
/**
 * Returns the control for the given page index, or <code>null</code>
 * if no control has been set for the page.
 * The page index must be valid.
 * <p>
 * Subclasses should not override this method
 * </p>
 *
 * @param pageIndex the index of the page
 * @return the control for the specified page, or <code>null</code> if none has been set
 */
protected Control getControl(int pageIndex) {
	return getItem(pageIndex).getControl();
}
/**
 * Returns the editor for the given page index.
 * The page index must be valid.
 *
 * @param pageIndex the index of the page
 * @return the editor for the specified page, or <code>null</code> if the
 *   specified page was not created with 
 *   <code>addPage(IEditorPart,IEditorInput)</code>
 */
protected IEditorPart getEditor(int pageIndex) {
	Item item = getItem(pageIndex);
	if (item != null) {
		Object data = item.getData();
		if (data instanceof IEditorPart) {
			return (IEditorPart) data;
		}
	}
	return null;
}
/**
 * Returns the tab item for the given page index (page index is 0-based).
 * The page index must be valid.
 *
 * @param pageIndex the index of the page
 * @return the tab item for the given page index
 */
private CTabItem getItem(int pageIndex) {
	return getTabFolder().getItem(pageIndex);
}
/**
 * Returns the number of pages in this multi-page editor.
 *
 * @return the number of pages
 */
protected int getPageCount() {
	CTabFolder folder = getTabFolder();
	// May not have been created yet, or may have been disposed.
	if (folder != null && !folder.isDisposed())
		return folder.getItemCount();
	return 0;
}
/**
 * Returns the image for the page with the given index,
 * or <code>null</code> if no image has been set for the page.
 * The page index must be valid.
 *
 * @param pageIndex the index of the page
 * @return the image, or <code>null</code> if none
 */
protected Image getPageImage(int pageIndex) {
	return getItem(pageIndex).getImage();
}
/**
 * Returns the text label for the page with the given index.
 * Returns the empty string if no text label has been set for the page.
 * The page index must be valid.
 *
 * @param pageIndex the index of the page
 * @return the text label for the page
 */
protected String getPageText(int pageIndex) {
	return getItem(pageIndex).getText();
}
/**
 * Returns the tab folder containing this multi-page editor's pages.
 *
 * @return the tab folder, or <code>null</code> if <code>createPartControl</code>
 *   has not been called yet
 */
private CTabFolder getTabFolder() {
	return container;
}
/**
 * Handles a property change notification from a nested editor.
 * The default implementation simply forwards the change to listeners
 * on this multi-page editor by calling <code>firePropertyChange</code>
 * with the same property id.  For example, if the dirty state of a nested editor
 * changes (property id <code>IEditorPart.PROP_DIRTY</code>), this method
 * handles it by firing a property change event for <code>IEditorPart.PROP_DIRTY</code>
 * to property listeners on this multi-page editor.
 * <p>
 * Subclasses may extend or reimplement this method.
 * </p>
 *
 * @param propertyId the id of the property that changed
 */
protected void handlePropertyChange (int propertyId) {
	firePropertyChange(propertyId);
}
/**
 * The <code>MultiPageEditorPart</code> implementation of this 
 * <code>IEditorPart</code> method sets its site to the given site, its 
 * input to the given input, and the site's selection provider to a
 * <code>MultiPageSelectionProvider</code>.
 * Subclasses may extend this method.
 */
public void init(IEditorSite site, IEditorInput input) throws PartInitException {
	setSite(site);
	setInput(input);
	site.setSelectionProvider(new MultiPageSelectionProvider(this));
}
/**
 * The <code>MultiPageEditorPart</code> implementation of this 
 * <code>IEditorPart</code> method returns whether the contents of any of this
 * multi-page editor's nested editors have changed since the last save.
 * Pages created with <code>addPage(Control)</code> are ignored.
 * <p>
 * Subclasses may extend or reimplement this method.
 * </p>
 */
public boolean isDirty() {
	// use nestedEditors to avoid SWT requests; see bug 12996
	for (Iterator i = nestedEditors.iterator(); i.hasNext();) {
		IEditorPart editor = (IEditorPart) i.next();
		if (editor.isDirty()) {
			return true;
		}
	}
	return false;
}
/**
 * Notifies this multi-page editor that the page with the given id has been
 * activated. This method is called when the user selects a different tab.
 * <p>
 * The <code>MultiPageEditorPart</code> implementation of this method 
 * sets focus to the new page, and notifies the action bar contributor (if there is one).
 * This checks whether the action bar contributor is an instance of 
 * <code>MultiPageEditorActionBarContributor</code>, and, if so,
 * calls <code>setActivePage</code> with the active nested editor.
 * This also fires a selection change event if required.
 * </p>
 * <p>
 * Subclasses may extend this method.
 * </p>
 *
 * @param newPageIndex the index of the activated page 
 */
protected void pageChange(int newPageIndex) {
	// XXX: Workaround for 1GCN531: SWT:WIN2000 - CTabFolder child's visibility is false on notification
	Control control = getControl(newPageIndex);
	if (control != null) {
		control.setVisible(true);
	}
	// XXX: End workaround
	setFocus();
	IEditorPart activeEditor = getEditor(newPageIndex);
	IEditorActionBarContributor contributor = getEditorSite().getActionBarContributor();
	if (contributor != null && contributor instanceof MultiPageEditorActionBarContributor) {
		((MultiPageEditorActionBarContributor) contributor).setActivePage(activeEditor);
	}
	if (activeEditor != null) {
		//Workaround for 1GAUS7C: ITPUI:ALL - Editor not activated when restored from previous session
		//do not need second if once fixed
		ISelectionProvider selectionProvider = activeEditor.getSite().getSelectionProvider();
		if (selectionProvider != null) {
			SelectionChangedEvent event = new SelectionChangedEvent(selectionProvider, selectionProvider.getSelection());
			((MultiPageSelectionProvider) getSite().getSelectionProvider()).fireSelectionChanged(event);
		}
	}
}
/**
 * Removes the page with the given index from this multi-page editor.
 * The controls for the page are disposed of; if the page has an editor, 
 * it is disposed of too. The page index must be valid.
 *
 * @param pageIndex the index of the page
 * @see #addPage
 */
public void removePage(int pageIndex) {
	Assert.isTrue(pageIndex >= 0 && pageIndex < getPageCount());
	// get editor (if any) before disposing item
	IEditorPart editor = getEditor(pageIndex);
	// dispose item before disposing editor, in case there's an exception in editor's dispose
	getItem(pageIndex).dispose();
	// dispose editor (if any)
	if (editor != null) {
		nestedEditors.remove(editor);
		editor.dispose();
	}
}
/**
 * Sets the currently active page.
 *
 * @param pageIndex the index of the page to be activated; the index must be valid
 */
protected void setActivePage(int pageIndex) {
	Assert.isTrue(pageIndex >= 0 && pageIndex < getPageCount());
	getTabFolder().setSelection(pageIndex);
}
/**
 * Sets the control for the given page index.
 * The page index must be valid.
 *
 * @param pageIndex the index of the page
 * @param control the control for the specified page, or <code>null</code> to clear the control
 */
protected void setControl(int pageIndex, Control control) {
	getItem(pageIndex).setControl(control);
}
/**
 * The <code>MultiPageEditor</code> implementation of this 
 * <code>IWorkbenchPart</code> method sets focus on the active nested editor,
 * if there is one.
 * <p>
 * Subclasses may extend or reimplement.
 * </p>
 */
public void setFocus() {
	int index = getActivePage();
	if (index != -1)
		setFocus(index);
}
/**
 * Sets focus to the control for the given page.
 * If the page has an editor, this calls its <code>setFocus()</code> method.
 * Otherwise, this calls <code>setFocus</code> on the control for the page.
 *
 * @pageIndex the index of the page
 */
private void setFocus(int pageIndex) {
	if (pageIndex < 0 || pageIndex >= getPageCount())
		return;
	IEditorPart editor = getEditor(pageIndex);
	if (editor != null) {
		editor.setFocus();
	} else {
		Control control = getControl(pageIndex);
		if (control != null) {
			control.setFocus();
		}
	}
}
/**
 * Sets the image for the page with the given index, or <code>null</code>
 * to clear the image for the page.
 * The page index must be valid.
 *
 * @param pageIndex the index of the page
 * @param image the image, or <code>null</code>
 */
protected void setPageImage(int pageIndex, Image image) {
	getItem(pageIndex).setImage(image);
}
/**
 * Sets the text label for the page with the given index.
 * The page index must be valid.
 * The text label must not be null.
 *
 * @param pageIndex the index of the page
 * @param text the text label
 */
protected void setPageText(int pageIndex, String text) {
	getItem(pageIndex).setText(text);
}
}