Attachment #160329 for bug #300237




import org.eclipse.jface.action.*;
import org.eclipse.jface.viewers.*;
import org.eclipse.team.internal.ui.*;
import org.eclipse.team.internal.ui.mapping.*;
import org.eclipse.team.internal.ui.mapping.ResourceMergeHandler;
import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
import org.eclipse.team.ui.synchronize.ModelSynchronizeParticipant;
import org.eclipse.ui.IWorkbenchActionConstants;


	protected void handleMenuAboutToShow(IMenuManager manager) {
		StructuredSelection selection = new StructuredSelection(((IResourceProvider)getCompareInput()).getResource());
		final ResourceMarkAsMergedHandler markAsMergedHandler = new ResourceMarkAsMergedHandler(getSynchronizeConfiguration());
		markAsMergedHandler.updateEnablement(selection);
		Action markAsMergedAction = new Action(TeamUIMessages.ModelCompareEditorInput_0) {
			public void run() {
				try {
					markAsMergedHandler.execute(new ExecutionEvent());
				} catch (ExecutionException e) {
					TeamUIPlugin.log(IStatus.ERROR, e.getMessage(), e);
				}
			}
			
		};
		Utils.initAction(markAsMergedAction, "action.markAsMerged."); //$NON-NLS-1$
		markAsMergedAction.setEnabled(markAsMergedAction.isEnabled());
		
		final ResourceMergeHandler mergeHandler = new ResourceMergeHandler(getSynchronizeConfiguration(), false);
		mergeHandler.updateEnablement(selection);
		Action mergeAction = new Action(TeamUIMessages.ModelCompareEditorInput_1) {

		mergeAction.setEnabled(mergeAction.isEnabled());

		manager.insertAfter(IWorkbenchActionConstants.MB_ADDITIONS, new Separator("merge")); //$NON-NLS-1$
		manager.insertAfter("merge", markAsMergedAction); //$NON-NLS-1$
		manager.insertAfter("merge", mergeAction); //$NON-NLS-1$
	}


Lines 63-71 Link Here

(-)src/org/eclipse/team/internal/ui/synchronize/patch/ApplyPatchModelSynchronizeParticipant.java (-3 lines)
63	if (mergeActionId == SynchronizationActionProvider.OVERWRITE_ACTION_ID) {	63	if (mergeActionId == SynchronizationActionProvider.OVERWRITE_ACTION_ID) {
64	// omit this action	64	// omit this action
65	return;	65	return;
66	} else if (mergeActionId == SynchronizationActionProvider.MARK_AS_MERGE_ACTION_ID) {
67	// omit this action
68	return;
69	}	66	}
70	super.addToContextMenu(mergeActionId, action, manager);	67	super.addToContextMenu(mergeActionId, action, manager);
71	}	68	}




import org.eclipse.core.runtime.jobs.ISchedulingRule;
import org.eclipse.team.core.diff.IDiff;
import org.eclipse.team.core.mapping.ISynchronizationScopeManager;
import org.eclipse.team.core.mapping.provider.ResourceDiffTree;
import org.eclipse.team.core.subscribers.Subscriber;
import org.eclipse.team.core.subscribers.SubscriberMergeContext;



	public void markAsMerged(IDiff node, boolean inSyncHint,
			IProgressMonitor monitor) throws CoreException {
		ResourceDiffTree tree = (ResourceDiffTree)getDiffTree();
		IResource resource = tree.getResource(node);
		WorkspacePatcher patcher = ((ApplyPatchSubscriber) getSubscriber()).getPatcher();
		Object object = PatchModelProvider.getPatchObject(resource, patcher);
		try {
			tree.beginInput();
			if (object instanceof FilePatch2) {
				FilePatch2 filePatch = (FilePatch2) object;
				FileDiffResult fileDiffResult = patcher.getDiffResult(filePatch);
				HunkResult[] hunkResults = fileDiffResult.getHunkResults();
				for (int i = 0; i < hunkResults.length; i++) {
					if (inSyncHint) {
						// disable hunks that were merged
						if (hunkResults[i].isOK())
							patcher.setEnabled(hunkResults[i].getHunk(), false);
					} else {
						patcher.setManuallyMerged(hunkResults[i].getHunk(), true);
					}
				}
			} else {
				patcher.setEnabled(object, false);
				// TODO: mark as merged
			}
			tree.remove(resource);
		} finally {
			tree.endInput(monitor);
		}
	}


Lines 10-15 Link Here

(-)src/org/eclipse/team/internal/ui/synchronize/patch/ApplyPatchSynchronizationActionProvider.java (-2 / +5 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.team.internal.ui.synchronize.patch;	11	package org.eclipse.team.internal.ui.synchronize.patch;
12		12
		13	import org.eclipse.team.internal.ui.mapping.ResourceMarkAsMergedHandler;
13	import org.eclipse.team.ui.mapping.SynchronizationActionProvider;	14	import org.eclipse.team.ui.mapping.SynchronizationActionProvider;
14	import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;	15	import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
15		16
Lines 23-32 Link Here
23	protected void initialize() {	24	protected void initialize() {
24	super.initialize();	25	super.initialize();
25	final ISynchronizePageConfiguration configuration = getSynchronizePageConfiguration();	26	final ISynchronizePageConfiguration configuration = getSynchronizePageConfiguration();
26	// We provide custom handler that is disabled for hunks.	27	// Provide custom handler, disabled for hunks.
27	registerHandler(MERGE_ACTION_ID, new ApplyPatchMergeActionHandler(	28	registerHandler(MERGE_ACTION_ID, new ApplyPatchMergeActionHandler(
28	configuration, false));	29	configuration, false));
29	// 'Overwrite' and 'Mark as merged' actions are not shown, see	30	registerHandler(MARK_AS_MERGE_ACTION_ID,
		31	new ResourceMarkAsMergedHandler(configuration));
		32	// 'Overwrite' action is not shown, see
30	// ApplyPatchModelSynchronizeParticipant.ApplyPatchModelSynchronizeParticipantActionGroup.addToContextMenu(String,	33	// ApplyPatchModelSynchronizeParticipant.ApplyPatchModelSynchronizeParticipantActionGroup.addToContextMenu(String,
31	// Action, IMenuManager)	34	// Action, IMenuManager)
32	}	35	}




/*******************************************************************************
 * 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.internal.patch.PatchDiffNode;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;

public class ExcludedPatchDiffNodesFilter extends ViewerFilter {

	private static ViewerFilter filter;

	public static ViewerFilter getInstance() {
		if (filter == null)
			filter = new ExcludedPatchDiffNodesFilter();
		return filter;
	}

	public ExcludedPatchDiffNodesFilter() {
		super();
	}

	public boolean select(Viewer viewer, Object parentElement, Object element) {
		if (element instanceof PatchDiffNode) {
			PatchDiffNode node = (PatchDiffNode) element;
			return node.isEnabled();
		}
		return true;
	}
}




 *******************************************************************************/
package org.eclipse.team.internal.ui.synchronize.patch;

import org.eclipse.compare.internal.patch.*;
import org.eclipse.compare.internal.patch.PatchDiffNode;
import org.eclipse.compare.structuremergeviewer.IDiffElement;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.mapping.*;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.*;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.team.core.mapping.ISynchronizationContext;
import org.eclipse.team.core.mapping.ISynchronizationScope;
import org.eclipse.team.core.subscribers.Subscriber;
import org.eclipse.team.internal.ui.TeamUIPlugin;
import org.eclipse.team.internal.ui.mapping.SynchronizationResourceMappingContext;
import org.eclipse.team.ui.mapping.SynchronizationContentProvider;

	}

	protected Object getModelRoot() {
		return PatchModelProvider.getPatchWorkspace(getSubscriber());
	}
	
	private Subscriber getSubscriber() {
		if (getContext() instanceof ApplyPatchSubscriberMergeContext) {
			ApplyPatchSubscriberMergeContext context = (ApplyPatchSubscriberMergeContext) getContext();
			return context.getSubscriber();
		}
		// TODO: assertion?
		return null;
	}
	
	/*
	 * Copied from
	 * org.eclipse.team.examples.model.ui.mapping.ModelSyncContentProvider

		}
		return false;
	}
	
	private class ExcludedPatchDiffNodesFilter extends ViewerFilter {

		public boolean select(Viewer viewer, Object parentElement, Object element) {
			if (element instanceof PatchDiffNode) {
				PatchDiffNode node = (PatchDiffNode) element;
				if (!node.isEnabled())
					return false;
				if (node instanceof PatchFileDiffNode) {
					// when at least one hunk is manually merged, hide the node
					PatchFileDiffNode file = (PatchFileDiffNode) node;
					IDiffElement[] children = file.getChildren();
					for (int i = 0; i < children.length; i++) {
						if (children[i] instanceof HunkDiffNode) {
							HunkDiffNode hunk = (HunkDiffNode) children[i];
							WorkspacePatcher patcher = ((ApplyPatchSubscriber)PatchSyncContentProvider.this.getSubscriber()).getPatcher();
							if (patcher.isManuallyMerged(hunk.getHunkResult().getHunk()))
								return false;
						}
					}
				}
			}
			return true;
		}
	}
	
	private ViewerFilter filter;
	
	public ViewerFilter getInstance() {
		if (filter == null)
			filter = new ExcludedPatchDiffNodesFilter();
		return filter;
	}
	
	public void propertyChange(PropertyChangeEvent event) {
		super.propertyChange(event);
		if (event.getProperty().equals(ModelSynchronizeParticipant.P_VISIBLE_MODEL_PROVIDER)) {

		}
	}

	private void addFilter(Viewer v) {
		if (v != null && v instanceof CommonViewer) {
			CommonViewer cv = (CommonViewer) v;
			cv.addFilter(getInstance());
		}
	}

	private void removeFilter(Viewer v) {
		if (v != null && v instanceof CommonViewer) {
			CommonViewer cv = (CommonViewer) v;
			cv.removeFilter(getInstance());
		}
	}
	
	public boolean hasChildren(final Object element) {
		if (element instanceof HunkDiffNode)
			return false;

Return to bug 300237

Lines 20-27 Link Here

(-)src/org/eclipse/team/internal/ui/synchronize/patch/ApplyPatchModelCompareEditorInput.java (-3 / +17 lines)
20	import org.eclipse.jface.action.*;	20	import org.eclipse.jface.action.*;
21	import org.eclipse.jface.viewers.*;	21	import org.eclipse.jface.viewers.*;
22	import org.eclipse.team.internal.ui.*;	22	import org.eclipse.team.internal.ui.*;
23	import org.eclipse.team.internal.ui.mapping.ModelCompareEditorInput;	23	import org.eclipse.team.internal.ui.mapping.*;
24	import org.eclipse.team.internal.ui.mapping.ResourceMergeHandler;
25	import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;	24	import org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration;
26	import org.eclipse.team.ui.synchronize.ModelSynchronizeParticipant;	25	import org.eclipse.team.ui.synchronize.ModelSynchronizeParticipant;
27	import org.eclipse.ui.IWorkbenchActionConstants;	26	import org.eclipse.ui.IWorkbenchActionConstants;
Lines 38-44 Link Here
38		37
39	protected void handleMenuAboutToShow(IMenuManager manager) {	38	protected void handleMenuAboutToShow(IMenuManager manager) {
40	StructuredSelection selection = new StructuredSelection(((IResourceProvider)getCompareInput()).getResource());	39	StructuredSelection selection = new StructuredSelection(((IResourceProvider)getCompareInput()).getResource());
41		40	final ResourceMarkAsMergedHandler markAsMergedHandler = new ResourceMarkAsMergedHandler(getSynchronizeConfiguration());
		41	markAsMergedHandler.updateEnablement(selection);
		42	Action markAsMergedAction = new Action(TeamUIMessages.ModelCompareEditorInput_0) {
		43	public void run() {
		44	try {
		45	markAsMergedHandler.execute(new ExecutionEvent());
		46	} catch (ExecutionException e) {
		47	TeamUIPlugin.log(IStatus.ERROR, e.getMessage(), e);
		48	}
		49	}
		50
		51	};
		52	Utils.initAction(markAsMergedAction, "action.markAsMerged."); //$NON-NLS-1$
		53	markAsMergedAction.setEnabled(markAsMergedAction.isEnabled());
		54
42	final ResourceMergeHandler mergeHandler = new ResourceMergeHandler(getSynchronizeConfiguration(), false);	55	final ResourceMergeHandler mergeHandler = new ResourceMergeHandler(getSynchronizeConfiguration(), false);
43	mergeHandler.updateEnablement(selection);	56	mergeHandler.updateEnablement(selection);
44	Action mergeAction = new Action(TeamUIMessages.ModelCompareEditorInput_1) {	57	Action mergeAction = new Action(TeamUIMessages.ModelCompareEditorInput_1) {
Lines 54-59 Link Here
54	mergeAction.setEnabled(mergeAction.isEnabled());	67	mergeAction.setEnabled(mergeAction.isEnabled());
55		68
56	manager.insertAfter(IWorkbenchActionConstants.MB_ADDITIONS, new Separator("merge")); //$NON-NLS-1$	69	manager.insertAfter(IWorkbenchActionConstants.MB_ADDITIONS, new Separator("merge")); //$NON-NLS-1$
		70	manager.insertAfter("merge", markAsMergedAction); //$NON-NLS-1$
57	manager.insertAfter("merge", mergeAction); //$NON-NLS-1$	71	manager.insertAfter("merge", mergeAction); //$NON-NLS-1$
58	}	72	}
59		73

Lines 18-23 Link Here

(-)src/org/eclipse/team/internal/ui/synchronize/patch/ApplyPatchSubscriberMergeContext.java (-13 / +25 lines)
18	import org.eclipse.core.runtime.jobs.ISchedulingRule;	18	import org.eclipse.core.runtime.jobs.ISchedulingRule;
19	import org.eclipse.team.core.diff.IDiff;	19	import org.eclipse.team.core.diff.IDiff;
20	import org.eclipse.team.core.mapping.ISynchronizationScopeManager;	20	import org.eclipse.team.core.mapping.ISynchronizationScopeManager;
		21	import org.eclipse.team.core.mapping.provider.ResourceDiffTree;
21	import org.eclipse.team.core.subscribers.Subscriber;	22	import org.eclipse.team.core.subscribers.Subscriber;
22	import org.eclipse.team.core.subscribers.SubscriberMergeContext;	23	import org.eclipse.team.core.subscribers.SubscriberMergeContext;
23		24
Lines 44-64 Link Here
44		45
45	public void markAsMerged(IDiff node, boolean inSyncHint,	46	public void markAsMerged(IDiff node, boolean inSyncHint,
46	IProgressMonitor monitor) throws CoreException {	47	IProgressMonitor monitor) throws CoreException {
47	IResource resource = getDiffTree().getResource(node);	48	ResourceDiffTree tree = (ResourceDiffTree)getDiffTree();
48	WorkspacePatcher patcher = ((ApplyPatchSubscriber) getSubscriber())	49	IResource resource = tree.getResource(node);
49	.getPatcher();	50	WorkspacePatcher patcher = ((ApplyPatchSubscriber) getSubscriber()).getPatcher();
50	Object object = PatchModelProvider.getPatchObject(resource, patcher);	51	Object object = PatchModelProvider.getPatchObject(resource, patcher);
51	if (object instanceof FilePatch2) {	52	try {
52	FilePatch2 filePatch = (FilePatch2) object;	53	tree.beginInput();
53	FileDiffResult fileDiffResult = patcher.getDiffResult(filePatch);	54	if (object instanceof FilePatch2) {
54	HunkResult[] hunkResults = fileDiffResult.getHunkResults();	55	FilePatch2 filePatch = (FilePatch2) object;
55	for (int i = 0; i < hunkResults.length; i++) {	56	FileDiffResult fileDiffResult = patcher.getDiffResult(filePatch);
56	// disable hunks that were merged	57	HunkResult[] hunkResults = fileDiffResult.getHunkResults();
57	if (hunkResults[i].isOK())	58	for (int i = 0; i < hunkResults.length; i++) {
58	patcher.setEnabled(hunkResults[i].getHunk(), false);	59	if (inSyncHint) {
		60	// disable hunks that were merged
		61	if (hunkResults[i].isOK())
		62	patcher.setEnabled(hunkResults[i].getHunk(), false);
		63	} else {
		64	patcher.setManuallyMerged(hunkResults[i].getHunk(), true);
		65	}
		66	}
		67	} else {
		68	patcher.setEnabled(object, false);
		69	// TODO: mark as merged
59	}	70	}
60	} else {	71	tree.remove(resource);
61	patcher.setEnabled(object, false);	72	} finally {
		73	tree.endInput(monitor);
62	}	74	}
63	}	75	}
64		76

Removed Link Here

(-)src/org/eclipse/team/internal/ui/synchronize/patch/ExcludedPatchDiffNodesFilter.java (-38 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11	package org.eclipse.team.internal.ui.synchronize.patch;
12
13	import org.eclipse.compare.internal.patch.PatchDiffNode;
14	import org.eclipse.jface.viewers.Viewer;
15	import org.eclipse.jface.viewers.ViewerFilter;
16
17	public class ExcludedPatchDiffNodesFilter extends ViewerFilter {
18
19	private static ViewerFilter filter;
20
21	public static ViewerFilter getInstance() {
22	if (filter == null)
23	filter = new ExcludedPatchDiffNodesFilter();
24	return filter;
25	}
26
27	public ExcludedPatchDiffNodesFilter() {
28	super();
29	}
30
31	public boolean select(Viewer viewer, Object parentElement, Object element) {
32	if (element instanceof PatchDiffNode) {
33	PatchDiffNode node = (PatchDiffNode) element;
34	return node.isEnabled();
35	}
36	return true;
37	}
38	}