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

 * Copyright (c) 2009 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.compare.contentmergeviewer;

import java.lang.reflect.Field;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import org.eclipse.compare.CompareConfiguration;

import org.eclipse.compare.internal.CompareUIPlugin;

import org.eclipse.core.runtime.Assert;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.jface.text.ITextViewer;

import org.eclipse.jface.text.TextViewer;

import org.eclipse.jface.text.source.ISourceViewer;

import org.eclipse.jface.text.source.SourceViewer;

import org.eclipse.swt.events.DisposeEvent;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.ui.IEditorInput;

import org.eclipse.ui.IEditorSite;

import org.eclipse.ui.IStorageEditorInput;

import org.eclipse.ui.IWorkbenchPart;

import org.eclipse.ui.IWorkbenchPartSite;

import org.eclipse.ui.PartInitException;

import org.eclipse.ui.editors.text.TextEditor;

import org.eclipse.ui.part.FileEditorInput;

import org.eclipse.ui.texteditor.AbstractTextEditor;

/**

 * @since 3.5

 */

public class TextEditorMergeViewer extends TextMergeViewer {

	private Map /*<TextEditorAdapter>*/ fEditor;

	private ArrayList/*<SourceViewer>*/ fSourceViewer;

	private IWorkbenchPartSite fSavedSite;

	public TextEditorMergeViewer(Composite parent, CompareConfiguration configuration) {

		super(parent, configuration);

	}

	protected void handleDispose(DisposeEvent event) {

		fSourceViewer= null;

		if (fEditor != null) {

			for (Iterator iterator= fEditor.values().iterator(); iterator.hasNext();) {

				TextEditorAdapter editor= (TextEditorAdapter)iterator.next();

				editor.dispose();

			}

			fEditor= null;

		}

		super.handleDispose(event);

	}

	protected void configureTextViewer(TextViewer viewer) {

		if (viewer instanceof SourceViewer) {

			SourceViewer sourceViewer = (SourceViewer) viewer;

			if (fSourceViewer == null)

				fSourceViewer = new ArrayList();

			if (!fSourceViewer.contains(sourceViewer))

				fSourceViewer.add(sourceViewer);

			IEditorInput editorInput = getEditorInput(sourceViewer);

			sourceViewer.unconfigure();

			if (editorInput == null) {

				// old-fashioned configuration

				super.configureTextViewer(viewer);

				return;

			}

			configureTextViewer(sourceViewer, editorInput);

		}

	}

	/*

	 * @see org.eclipse.compare.contentmergeviewer.TextMergeViewer#setEditable(org.eclipse.jface.text.source.ISourceViewer, boolean)

	 * @since 3.5

	 */

	protected void setEditable(ISourceViewer sourceViewer, boolean state) {

		super.setEditable(sourceViewer, state);

		if (fEditor != null) {

			Object editor= fEditor.get(sourceViewer);

			if (editor instanceof TextEditorAdapter)

				((TextEditorAdapter)editor).setEditable(state);

		}

	}

	/*

	 * @see org.eclipse.compare.contentmergeviewer.TextMergeViewer#isEditorBacked(org.eclipse.jface.text.ITextViewer)

	 * @since 3.5

	 */

	protected boolean isEditorBacked(ITextViewer textViewer) {

		return true;

	}

	protected IEditorInput getEditorInput(ISourceViewer sourceViewer) {

		IEditorInput editorInput= super.getEditorInput(sourceViewer);

		if (editorInput == null)

			return null;

		if (getSite() == null)

			return null;

		if (!isInputValid(editorInput))

			return null;

		return editorInput;

	}

	private IWorkbenchPartSite getSite() {

		IWorkbenchPart workbenchPart= getCompareConfiguration().getContainer().getWorkbenchPart();

		IWorkbenchPartSite site= null;

		if (workbenchPart != null)

			site = workbenchPart.getSite();

		if (fSavedSite == null)

			fSavedSite = site;

		// TODO: this is a hack

		return fSavedSite;

	}

	private boolean isInputValid(IEditorInput editorInput) {

		if (editorInput instanceof FileEditorInput) {

			FileEditorInput fileEditorInput= (FileEditorInput)editorInput;

			return fileEditorInput.getFile().isAccessible();

		} else if (editorInput instanceof IStorageEditorInput) {

			return true;

		}

		return false;

	}

	private void configureTextViewer(SourceViewer sourceViewer, IEditorInput editorInput) {

		if (editorInput != null) {

			// when input available, use editor

			TextEditorAdapter editor= (TextEditorAdapter)fEditor.get(sourceViewer);

			try {

				editor.init((IEditorSite)editor.getSite(), editorInput);

				editor.createActions();

			} catch (PartInitException e) {

				CompareUIPlugin.log(e);

			}

		}

	}

	protected ISourceViewer createSourceViewer(Composite parent, int textOrientation) {

		ISourceViewer sourceViewer = super.createSourceViewer(parent,

				textOrientation);

		TextEditorAdapter editor = new TextEditorAdapter();

		editor.setSourceViewer(sourceViewer);

		if (fEditor == null)

			fEditor = new HashMap(3);

		fEditor.put(sourceViewer, editor);

		if (fSourceViewer == null)

			fSourceViewer = new ArrayList();

		fSourceViewer.add(sourceViewer);

		return sourceViewer;

	}

	protected void setActionsActivated(SourceViewer sourceViewer, boolean state) {

		if (fEditor != null) {

			Object editor= fEditor.get(sourceViewer);

			if (editor instanceof TextEditorAdapter)

				((TextEditorAdapter)editor).setActionsActivated(state);

		}

	}

	private class TextEditorAdapter extends TextEditor {

		private boolean fInputSet = false;

		private boolean fEditable;

		private void setEditable(boolean editable) {

			fEditable= editable;

		}

		public IWorkbenchPartSite getSite() {

			if (TextEditorMergeViewer.this != null) // when called from super();

				return TextEditorMergeViewer.this.getSite();

			// TODO: any side effects?

			return null;

		}

		public void createActions() {

			if (fInputSet) {

				super.createActions();

			}

			// else do nothing, we will create actions later, when input is available

		}

		public void createPartControl(Composite composite) {

			// empty implementation

		}

		void setSourceViewer(ISourceViewer sourceViewer) {

			// no setter to private field AbstractTextEditor.fSourceViewer

			Field field= null;

			try {

				field= AbstractTextEditor.class.getDeclaredField("fSourceViewer"); //$NON-NLS-1$

			} catch (SecurityException ex) {

				CompareUIPlugin.log(ex);

			} catch (NoSuchFieldException ex) {

				CompareUIPlugin.log(ex);

			}

			field.setAccessible(true);

			try {

				field.set(this, sourceViewer);

			} catch (IllegalArgumentException ex) {

				CompareUIPlugin.log(ex);

			} catch (IllegalAccessException ex) {

				CompareUIPlugin.log(ex);

			}

			getSelectionProvider().addSelectionChangedListener(getSelectionChangedListener());

		}

		protected void doSetInput(IEditorInput input) throws CoreException {

			super.doSetInput(input);

			// the editor input has been explicitly set

			fInputSet = true;

		}

		public IEditorInput getEditorInput() {

			return fInputSet ? TextEditorMergeViewer.this.getEditorInput(getSourceViewer()) : super.getEditorInput();

		}

		public ISourceViewer getViewer() {

			return getSourceViewer();

		}

		// called by org.eclipse.ui.texteditor.TextEditorAction.canModifyEditor()

		public boolean isEditable() {

			return fEditable;

		}

		public boolean isEditorInputModifiable() {

			return fEditable;

		}

		public boolean isEditorInputReadOnly() {

			return !fEditable;

		}

		protected void setActionsActivated(boolean state) {

			Method method= null;

			try {

				method= AbstractTextEditor.class.getDeclaredMethod("setActionActivation", new Class[] { boolean.class }); //$NON-NLS-1$

			} catch (SecurityException ex) {

				CompareUIPlugin.log(ex);

			} catch (NoSuchMethodException ex) {

				CompareUIPlugin.log(ex);

			}

			Assert.isNotNull(method);

			method.setAccessible(true);

			try {

				method.invoke(this, new Object[] { new Boolean(state) });

			} catch (IllegalArgumentException ex) {

				CompareUIPlugin.log(ex);

			} catch (InvocationTargetException ex) {

				CompareUIPlugin.log(ex);

			} catch (IllegalAccessException ex) {

				CompareUIPlugin.log(ex);

			}

		}

	}

}

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

 * Copyright (c) 2009 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.compare.internal;

import org.eclipse.compare.CompareConfiguration;

import org.eclipse.compare.IViewerCreator;

import org.eclipse.compare.contentmergeviewer.TextEditorMergeViewer;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.swt.widgets.Composite;

/**

 * A factory object for the <code>TextEditorMergeViewer</code>.

 * This indirection is necessary because only objects with a default

 * constructor can be created via an extension point

 * (this precludes Viewers).

 */

public class TextEditorMergeViewerCreator implements IViewerCreator {

	public Viewer createViewer(Composite parent, CompareConfiguration mp) {

		return new TextEditorMergeViewer(parent, mp);

	}

}