/*******************************************************************************

 * Copyright (c) 2000, 2011 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 API and implementation

 *******************************************************************************/

package org.eclipse.ui.tests.multieditor;

import java.io.IOException;

import java.net.URL;

import java.util.ArrayList;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IWorkspace;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.FileLocator;

import org.eclipse.core.runtime.ILog;

import org.eclipse.core.runtime.ILogListener;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.swt.SWT;

import org.eclipse.swt.widgets.Event;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorPart;

import org.eclipse.ui.IEditorRegistry;

import org.eclipse.ui.IPageLayout;

import org.eclipse.ui.IViewPart;

import org.eclipse.ui.IWorkbenchPage;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.IWorkbenchWindow;

import org.eclipse.ui.internal.PartSite;

import org.eclipse.ui.internal.WorkbenchPage;

import org.eclipse.ui.internal.WorkbenchPlugin;

import org.eclipse.ui.part.FileEditorInput;

import org.eclipse.ui.part.MultiEditorInput;

import org.eclipse.ui.tests.TestPlugin;

import org.eclipse.ui.tests.harness.util.UITestCase;

public class AbstractMultiEditorTest extends UITestCase {

	private static final String PROJECT_NAME = "TiledEditorProject";

	private static final String TILED_EDITOR_ID = "org.eclipse.ui.tests.multieditor.ConcreteAbstractMultiEditor";

	// tiled editor test files

	private static final String DATA_FILES_DIR = "/data/org.eclipse.newMultiEditor/";

	private static final String TEST01_TXT = "test01.txt";

	private static final String TEST03_ETEST = "test03.etest";

	private EditorErrorListener fErrorListener;

	public AbstractMultiEditorTest(String tc) {

		super(tc);

	}

	public void testBug317102() throws Throwable {

		final String[] simpleFiles = { TEST01_TXT, TEST03_ETEST };

		IWorkbenchWindow window = openTestWindow();

		WorkbenchPage page = (WorkbenchPage) window.getActivePage();

		IProject testProject = findOrCreateProject(PROJECT_NAME);

		MultiEditorInput input = generateEditorInput(simpleFiles, testProject);

		IEditorPart editor = page.openEditor(input,

				AbstractMultiEditorTest.TILED_EDITOR_ID);

		// did we get a multieditor back?

		assertTrue(editor instanceof ConcreteAbstractMultiEditor);

		ConcreteAbstractMultiEditor multiEditor = (ConcreteAbstractMultiEditor) editor;

		IEditorPart[] innerEditors = multiEditor.getInnerEditors();

		IEditorPart activeEditor = multiEditor.getActiveEditor();

		assertEquals(activeEditor, innerEditors[0]);

		multiEditor.activateEditor(innerEditors[1]);

		// activate another view

		IViewPart view = page.showView(IPageLayout.ID_PROBLEM_VIEW);

		assertEquals(view, page.getActivePart());

		fakeActivation(innerEditors[0]);

	}

	private void fakeActivation(IWorkbenchPart part) {

		try {

			setupErrorListener();

			Event event = new Event();

			event.type = SWT.Activate;

			((PartSite) part.getSite()).getPane().handleEvent(event);

			assertTrue("Nothing should have been logged",

					fErrorListener.messages.isEmpty());

		} finally {

			removeErrorListener();

		}

	}

	/**

	 * Set up to catch any editor initialization exceptions.

	 * 

	 */

	private void setupErrorListener() {

		final ILog log = WorkbenchPlugin.getDefault().getLog();

		fErrorListener = new EditorErrorListener();

		log.addLogListener(fErrorListener);

	}

	/**

	 * Remove the editor error listener.

	 */

	private void removeErrorListener() {

		final ILog log = WorkbenchPlugin.getDefault().getLog();

		if (fErrorListener != null) {

			log.removeLogListener(fErrorListener);

			fErrorListener = null;

		}

	}

	/**

	 * Create the multi editor input in the given project. Creates the files in

	 * the project from template files in the classpath if they don't already

	 * exist.

	 * 

	 * @param simpleFiles

	 *            the array of filenames to copy over

	 * @param testProject

	 *            the project to create the files in

	 * @return the editor input used to open the multieditor

	 * @throws CoreException

	 * @throws IOException

	 */

	private MultiEditorInput generateEditorInput(String[] simpleFiles,

			IProject testProject) throws CoreException, IOException {

		String[] ids = new String[simpleFiles.length];

		IEditorInput[] inputs = new IEditorInput[simpleFiles.length];

		IEditorRegistry registry = fWorkbench.getEditorRegistry();

		for (int f = 0; f < simpleFiles.length; ++f) {

			IFile f1 = createFile(testProject, simpleFiles[f]);

			ids[f] = registry.getDefaultEditor(f1.getName()).getId();

			inputs[f] = new FileEditorInput(f1);

		}

		MultiEditorInput input = new MultiEditorInput(ids, inputs);

		return input;

	}

	/**

	 * Create the project to work in. If it already exists, just open it.

	 * 

	 * @param projectName

	 *            the name of the project to create

	 * @return the newly opened project

	 * @throws CoreException

	 */

	private static IProject findOrCreateProject(String projectName)

			throws CoreException {

		IWorkspace workspace = ResourcesPlugin.getWorkspace();

		IProject testProject = workspace.getRoot().getProject(projectName);

		if (!testProject.exists()) {

			testProject.create(null);

		}

		testProject.open(null);

		return testProject;

	}

	private static IFile createFile(IProject testProject, String simpleFile)

			throws CoreException, IOException {

		IFile file = testProject.getFile(simpleFile);

		if (!file.exists()) {

			URL url = FileLocator.toFileURL(TestPlugin.getDefault().getBundle()

					.getEntry(DATA_FILES_DIR + simpleFile));

			file.create(url.openStream(), true, null);

		}

		return file;

	}

	/**

	 * Close any editors at the beginner of a test, so the test can be clean.

	 */

	protected void doSetUp() throws Exception {

		super.doSetUp();

		IWorkbenchPage page = fWorkbench.getActiveWorkbenchWindow()

				.getActivePage();

		page.closeAllEditors(false);

	}

	/**

	 * Listens for the standard message that indicates the MultiEditor failed

	 * ... usually caused by incorrect framework initialization that doesn't set

	 * the innerChildren.

	 * 

	 * @since 3.1

	 * 

	 */

	public static class EditorErrorListener implements ILogListener {

		public ArrayList messages = new ArrayList();

		public void logging(IStatus status, String plugin) {

			String msg = status.getMessage();

			Throwable ex = status.getException();

			if (ex != null) {

				msg += ": " + ex.getMessage();

			}

			messages.add(msg);

		}

	}

}

/*******************************************************************************

 * Copyright (c) 2011 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 API and implementation

 *******************************************************************************/

package org.eclipse.ui.tests.multieditor;

import org.eclipse.swt.SWT;

import org.eclipse.swt.custom.SashForm;

import org.eclipse.swt.layout.FillLayout;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.ui.IEditorReference;

import org.eclipse.ui.part.AbstractMultiEditor;

public class ConcreteAbstractMultiEditor extends AbstractMultiEditor {

	private Composite left;

	private Composite right;

	private IEditorReference leftReference;

	protected void innerEditorsCreated() {

		// no-op

	}

	public Composite getInnerEditorContainer(

			IEditorReference innerEditorReference) {

		if (leftReference == null) {

			leftReference = innerEditorReference;

			return left;

		}

		return right;

	}

	public void createPartControl(Composite parent) {

		SashForm form = new SashForm(parent, SWT.HORIZONTAL);

		left = new Composite(form, SWT.NONE);

		left.setLayout(new FillLayout());

		right = new Composite(form, SWT.NONE);

		right.setLayout(new FillLayout());

		form.setWeights(new int[] { 50, 50 });

	}

}

        addTestSuite(AbstractMultiEditorTest.class);

            class="org.eclipse.ui.tests.multieditor.ConcreteAbstractMultiEditor"

            default="false"

            icon="icons/binary_co.gif"

            id="org.eclipse.ui.tests.multieditor.ConcreteAbstractMultiEditor"

            name="%Editors.TiledEditor"/>

      <editor

		/**

		 * @return Returns the parent editor reference that this reference is a

		 *         child of.

		 */

		public IEditorReference getOuterEditor() {

			return outerEditor;

		}

     * @see #getChildren()

    /**

	 * @return Returns the child editor references. May be <code>null</code> if

	 *         this is not a multi reference.

	 * @see #isMultiReference()

     */

	public IEditorReference[] getChildren() {

		return multiEditorChildren;

	}

            	// check if we're a nested editor reference

				if (partBeingActivated instanceof EditorManager.InnerEditor) {

					EditorReference outerEditor = (EditorReference) ((EditorManager.InnerEditor) partBeingActivated)

							.getOuterEditor();

					// get all the sibling references

					IEditorReference[] children = outerEditor.getChildren();

					if (children != null) {

						for (int i = 0; i < children.length; i++) {

							// there's a recursive activation request for a

							// sibling reference, ignore it

							if (children[i].getPart(false) == newPart) {

								return;

							}

						}

					}

				}