/*if (object instanceof PatchFileDiffNode) {

			if (participant instanceof ApplyPatchModelSynchronizeParticipant) {

				ApplyPatchModelSynchronizeParticipant apmsp = (ApplyPatchModelSynchronizeParticipant) participant;

				ISynchronizationContext context = apmsp.getContext();

				if (context instanceof ApplyPatchSubscriberMergeContext) {

					ApplyPatchSubscriberMergeContext apsmc = (ApplyPatchSubscriberMergeContext) context;

					try {

						Subscriber subscriber = apsmc.getSubscriber();

						SyncInfo info = subscriber.getSyncInfo(((PatchFileDiffNode)object).getResource());

						if (info != null)

							return openCompareEditorOnSyncInfo(configuration, info, keepFocus, reuseEditorIfPossible);

					} catch (TeamException e) {

						// TODO Auto-generated catch block

						e.printStackTrace();

					}

				}

			}

		}*/

					// TODO: //now, we never get here

import org.eclipse.compare.structuremergeviewer.ICompareInput;

import org.eclipse.team.internal.ui.Utils;

import org.eclipse.team.ui.mapping.ISynchronizationCompareAdapter;

	public ICompareInput asCompareInput(Object object) {

		ISynchronizationCompareAdapter adapter = Utils.getCompareAdapter(object);

		if (adapter != null)

			return adapter.asCompareInput(getContext(), object);

		if (object instanceof ICompareInput) {

			return (ICompareInput) object;

		}

		return null;

	}

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

 * Copyright (c) 2010 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.team.internal.ui.synchronize.patch;

import org.eclipse.compare.ITypedElement;

import org.eclipse.compare.internal.core.patch.HunkResult;

import org.eclipse.compare.internal.patch.*;

import org.eclipse.compare.patch.PatchConfiguration;

import org.eclipse.compare.structuremergeviewer.Differencer;

import org.eclipse.core.resources.IResource;

public class HunkDiffNode extends PatchDiffNode {

	private final HunkResult result;

	public static HunkDiffNode createDiffNode(PatchFileDiffNode parent, HunkResult result, boolean fullContext) {

		return createDiffNode(parent, result, fullContext, fullContext, fullContext);

	}

	public static HunkDiffNode createDiffNode(PatchFileDiffNode parent, HunkResult result, boolean ancestorFullContext, boolean leftFullContext, boolean rightFullContext) {

		return new HunkDiffNode(result, parent, Differencer.CHANGE, getAncestorElement(result, ancestorFullContext), getLeftElement(result, leftFullContext), getRightElement(result, rightFullContext));

	}

	private static ITypedElement getRightElement(HunkResult result, boolean fullContext) {

		return new HunkTypedElement(result, true /* isResult */, fullContext);

	}

	private static ITypedElement getLeftElement(HunkResult result,

			boolean fullContext) {

		if (fullContext && !result.isOK())

			return new UnmatchedHunkTypedElement(result);

		return new HunkTypedElement(result, false /* before state */, fullContext);

	}

	private static ITypedElement getAncestorElement(HunkResult result, boolean fullContext) {

		if (!fullContext && result.isOK()) {

			return new HunkTypedElement(result, false /* before state */, fullContext);

		}

		if (!fullContext) {

			// Don't provide an ancestor if the hunk didn't match or we're not doing fullContext

			return null;

		}

		// Make the ancestor the same as the left so we have an incoming change

		return new HunkTypedElement(result, false /* before state */, result.isOK());

	}

	private HunkDiffNode(HunkResult result, PatchFileDiffNode parent, int kind, ITypedElement ancestor, ITypedElement left, ITypedElement right) {

		super(result.getHunk(), parent, kind, ancestor, left, right);

		this.result = result;

	}

	public HunkResult getHunkResult() {

		return result;

	}

	protected PatchConfiguration getConfiguration() {

		return result.getDiffResult().getConfiguration();

	}

	public boolean isManuallyMerged() {

		Object left = getLeft();

		if (left instanceof UnmatchedHunkTypedElement) {

			UnmatchedHunkTypedElement element = (UnmatchedHunkTypedElement) left;

			return element.isManuallyMerged();

		}

		return false;

	}

	public boolean isFuzzUsed() {

		return result.getFuzz() > 0;

	}

	public boolean isAllContextIgnored() {

		int fuzz = result.getFuzz();

		if (fuzz > 0) {

			String[] lines = result.getHunk().getLines();

			int contextLines = 0;

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

				String line = lines[i];

				char c = line.charAt(0);

				if (c == ' ') {

					contextLines++;

				} else {

					if (contextLines > 0 && fuzz >= contextLines) {

						return true;

					}

					contextLines = 0;

				}

			}

			if (contextLines > 0 && fuzz >= contextLines) {

				return true;

			}

		}

		return false;

	}

	public IResource getResource() {

		return ((PatchFileDiffNode)getParent()).getResource();

	}

}

		if (o instanceof PatchFileDiffNode) 

			return super.asCompareInput(context, o);

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

 * Copyright (c) 2010 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.team.internal.ui.synchronize.patch;

import org.eclipse.compare.*;

import org.eclipse.compare.internal.core.patch.FileDiffResult;

import org.eclipse.compare.internal.core.patch.FilePatch2;

import org.eclipse.compare.internal.patch.*;

import org.eclipse.compare.patch.PatchConfiguration;

import org.eclipse.compare.structuremergeviewer.*;

import org.eclipse.core.internal.runtime.AdapterManager;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.team.internal.ui.synchronize.LocalResourceTypedElement;

public class PatchFileDiffNode extends PatchDiffNode implements IContentChangeListener, IAdaptable {

	private final FileDiffResult result;

	public static PatchFileDiffNode createDiffNode(DiffNode parent, FileDiffResult result) {

		return new PatchFileDiffNode(result, parent, getKind(result), getAncestorElement(result), getLeftElement(result), getRightElement(result));

	}

	private static int getKind(FileDiffResult result) {

		if (!result.hasMatches())

			return Differencer.NO_CHANGE;

		int fileDiffKind = result.getDiff().getDiffType(result.getConfiguration().isReversed());

		int kind = convertFileDiffTypeToDifferencerType(fileDiffKind);

		return kind | Differencer.RIGHT;

	}

	private static int convertFileDiffTypeToDifferencerType(int fileDiffKind) {

		int kind;

		switch (fileDiffKind) {

		case FilePatch2.ADDITION:

			kind = Differencer.ADDITION;

			break;

		case FilePatch2.DELETION:

			kind = Differencer.DELETION;

			break;

		case FilePatch2.CHANGE:

			kind = Differencer.CHANGE;

			break;

		default:

			kind = Differencer.CHANGE;

			break;

		}

		return kind;

	}

	private static ITypedElement getRightElement(FileDiffResult result) {

		return new PatchFileTypedElement(result, true);

	}

	private static ITypedElement getLeftElement(FileDiffResult result) {

		return new LocalResourceTypedElement(((WorkspaceFileDiffResult)result).getTargetFile());

//		return new PatchFileTypedElement(result, false);

	}

	private static ITypedElement getAncestorElement(FileDiffResult result) {

		return new PatchFileTypedElement(result, false);

	}

	public PatchFileDiffNode(FileDiffResult result, IDiffContainer parent, int kind,

			ITypedElement ancestor, ITypedElement left, ITypedElement right) {

		super(result.getDiff(), parent, kind, ancestor, left, right);

		this.result = result;

	}

	public FileDiffResult getDiffResult() {

		return result;

	}

	protected PatchConfiguration getConfiguration() {

		return result.getConfiguration();

	}

	/* (non-Javadoc)

	 * @see org.eclipse.compare.structuremergeviewer.DiffContainer#add(org.eclipse.compare.structuremergeviewer.IDiffElement)

	 */

	public void add(IDiffElement diff) {

		super.add(diff);

		// Listen for content changes in unmatched children so we can fire an input change

		if (diff instanceof HunkDiffNode) {

			HunkDiffNode node = (HunkDiffNode) diff;

			Object left = node.getLeft();

			if (left instanceof IContentChangeNotifier) {

				IContentChangeNotifier notifier = (IContentChangeNotifier) left;

				notifier.addContentChangeListener(this);

			}

		}

	}

	/* (non-Javadoc)

	 * @see org.eclipse.compare.IContentChangeListener#contentChanged(org.eclipse.compare.IContentChangeNotifier)

	 */

	public void contentChanged(IContentChangeNotifier source) {

		fireChange();

	}

	public int getKind() {

		int kind = super.getKind();

		if (kind == Differencer.NO_CHANGE && getPatcher().hasCachedContents(getDiffResult().getDiff())) {

			return Differencer.CHANGE | Differencer.RIGHT;

		}

		return kind;

	}

	public boolean fileExists() {

		IResource file = getResource();

		return file != null && file.isAccessible();

	}

	public IResource getResource() {

		return ((WorkspaceFileDiffResult)getDiffResult()).getTargetFile();

	}

	public Object getAdapter(Class adapter) {

		if (adapter == IResource.class)

			return getResource();

		return AdapterManager.getDefault().getAdapter(this, adapter);

	}

}