Attachment #148896 for bug #124039

Lines 278-284 Link Here

(-)src/org/eclipse/team/internal/ccvs/ui/messages.properties (-1 / +1 lines)
278	CommitWizardCommitPage_0=Commit	278	CommitWizardCommitPage_0=Commit
279	CommitWizardCommitPage_2=Enter a comment for the commit operation.	279	CommitWizardCommitPage_2=Enter a comment for the commit operation.
280	CommitWizardCommitPage_3=Please enter a commit comment.	280	CommitWizardCommitPage_3=Please enter a commit comment.
281	CommitWizardCommitPage_4=Conflicting changes cannot be committed. Either exclude them from the commit or use the synchronize view to resolve the conflicts.	281	CommitWizardCommitPage_4=Conflicting changes cannot be committed. Either exclude them from the commit or resolve the conflicts.
282	CommitWizardCommitPage_1=Hiding changes. The {0} changes exceeds the display threshold of {1}. It may take a long time to show this number of changes.	282	CommitWizardCommitPage_1=Hiding changes. The {0} changes exceeds the display threshold of {1}. It may take a long time to show this number of changes.
283	CommitWizardCommitPage_5=Show &Changes	283	CommitWizardCommitPage_5=Show &Changes
284	CommitWizardFileTypePage_0=Add Resources	284	CommitWizardFileTypePage_0=Add Resources




/*******************************************************************************
 * Copyright (c) 2000, 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

package org.eclipse.team.internal.ccvs.ui.wizards;

import java.lang.reflect.InvocationTargetException;
import java.util.*;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.core.resources.*;
import org.eclipse.core.resources.mapping.ResourceMapping;
import org.eclipse.core.resources.mapping.ResourceTraversal;
import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.jobs.*;
import org.eclipse.core.runtime.jobs.IJobChangeListener;
import org.eclipse.jface.dialogs.*;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.swt.widgets.Shell;
import org.eclipse.team.core.IFileContentManager;
import org.eclipse.team.core.Team;
import org.eclipse.team.core.diff.*;
import org.eclipse.team.core.mapping.*;
import org.eclipse.team.core.synchronize.SyncInfoSet;
import org.eclipse.team.internal.ccvs.core.*;
import org.eclipse.team.internal.ccvs.core.client.Command;
import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
import org.eclipse.team.internal.ccvs.ui.*;
import org.eclipse.team.internal.ccvs.ui.actions.CommitAction;
import org.eclipse.team.internal.ccvs.ui.mappings.AbstractCommitAction;
import org.eclipse.team.internal.ccvs.ui.mappings.WorkspaceSubscriberContext;
import org.eclipse.team.internal.ccvs.ui.operations.*;
import org.eclipse.team.internal.core.subscribers.SubscriberDiffTreeEventHandler;
import org.eclipse.team.internal.ui.Policy;
import org.eclipse.team.internal.ui.Utils;
import org.eclipse.team.ui.synchronize.ModelSynchronizeParticipant;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;


    }
    
    private final IResource[] fResources;
    private IResource[] fUnaddedDiffs;
    private final ModelSynchronizeParticipant fParticipant;
    private final CommitWizardParticipant fParticipant;
    
    private CommitWizardFileTypePage fFileTypePage;
    private CommitWizardCommitPage fCommitPage;

        setDefaultPageImageDescriptor(CVSUIPlugin.getPlugin().getImageDescriptor(ICVSUIConstants.IMG_WIZBAN_NEW_LOCATION));
        
        fResources= resources;
        ResourceMapping[] mappings = Utils.getResourceMappings(resources);
        fParticipant = createWorkspaceParticipant(mappings, getShell());

        getAllOutOfSync();
        fUnaddedDiffs = getUnaddedResources(getDiffTree().getAffectedResources());
    }

	private ModelSynchronizeParticipant createWorkspaceParticipant(ResourceMapping[] selectedMappings, Shell shell) {
		ISynchronizationScopeManager manager = WorkspaceSubscriberContext.createWorkspaceScopeManager(selectedMappings, true, CommitAction.isIncludeChangeSets(shell, CVSUIMessages.SyncAction_1));
		return new CommitWizardParticipant(WorkspaceSubscriberContext.createContext(manager, ISynchronizationContext.THREE_WAY), this);
	}

	public CommitWizard(SyncInfoSet infos, IJobChangeListener jobListener) throws CVSException {
		this(infos);
		this.jobListener = jobListener;
	}

	private void getAllOutOfSync() throws CVSException {
		try {
			PlatformUI.getWorkbench().getProgressService().run(true, true, new IRunnableWithProgress() {
				public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
					monitor.beginTask(null, IProgressMonitor.UNKNOWN);

					ISynchronizationContext context = getParticipant().getContext();
					SubscriberDiffTreeEventHandler handler = (SubscriberDiffTreeEventHandler) Utils.getAdapter(context,	SubscriberDiffTreeEventHandler.class);
					handler.initializeIfNeeded();
					Job.getJobManager().join(context, monitor);

					if (monitor.isCanceled()) {
						throw new InterruptedException();
					}
					monitor.done();
				}
			});
		} catch (InvocationTargetException e) {
			throw CVSException.wrapException(e);
		} catch(InterruptedException e) {
			throw new OperationCanceledException();
		}
	}
    
    public boolean hasOutgoingChanges() {
    	IResourceDiffTree tree = getDiffTree();
		return tree != null && tree.hasMatchingDiffs(ResourcesPlugin.getWorkspace().getRoot().getFullPath(), new FastDiffFilter() {
			public boolean select(IDiff diff) {
				return AbstractCommitAction.hasLocalChange(diff);
			}
		});
    }
    
    boolean hasConflicts() {
    	IResourceDiffTree tree = getDiffTree();
		return tree != null && tree.hasMatchingDiffs(ResourcesPlugin.getWorkspace().getRoot().getFullPath(), new FastDiffFilter() {
			public boolean select(IDiff diff) {
				if (diff instanceof IThreeWayDiff) {
					IThreeWayDiff twd = (IThreeWayDiff) diff;
					return twd.getDirection() == IThreeWayDiff.CONFLICTING;
				}
				return false;
			}
		});
	}
    
    public int getHighestProblemSeverity() {
		IResource[] resources = getDiffTree().getAffectedResources();
    	int mostSeriousSeverity = -1;
    	
    	for (int i = 0; i < resources.length; i++) {

    	
    	return mostSeriousSeverity;
    }

	IResourceDiffTree getDiffTree() {
		return fParticipant.getContext().getDiffTree();
	}

    public CommitWizardFileTypePage getFileTypePage() {
        return fFileTypePage;
    }

        return fCommitPage;
    }

	public ModelSynchronizeParticipant getParticipant() {
        return fParticipant;
    }


        if (comment == null)
            return false;
        
        IResource[] resources = AbstractCommitAction.getOutgoingChanges(getDiffTree(), fCommitPage.getTraversalsToCommit(), null);
        if (resources.length == 0)
			return true;
        
        final IResource[] unadded;
        try {
            unadded = getUnaddedResources(resources);
        } catch (CVSException e1) {
            return false;
        }
        
        final IResource[] files = getFiles(resources);
        try {
            files = getFiles(infos);
        } catch (CVSException e1) {
            return false;
        }
        
        final AddAndCommitOperation operation= new AddAndCommitOperation(getPart(), files, unadded, comment);
        if (jobListener != null)
        	operation.setJobChangeListener(jobListener);
        

        
        final Collection names= new HashSet();
        final Collection extensions= new HashSet();
        getUnknownNamesAndExtension(fUnaddedDiffs, names, extensions);
        
        if (names.size() + extensions.size() > 0) {
            fFileTypePage= new CommitWizardFileTypePage(extensions, names); 

        return dialog.open();
    }
    
    private void getUnknownNamesAndExtension(IResource[] resources, Collection names, Collection extensions) {

    	final IFileContentManager manager= Team.getFileContentManager();

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

    		IResource local = resources[i];
    		if (local instanceof IFile && manager.getType((IFile)local) == Team.UNKNOWN) {
    			final String extension= local.getFileExtension();
    			if (extension != null && !manager.isKnownExtension(extension)) {
    				extensions.add(extension);
    			}

    			final String name= local.getName();
    			if (extension == null && name != null && !manager.isKnownFilename(name))
    				names.add(name);
    		}
    	}
            }
        }
    }
    
    private static SyncInfoSet getUnaddedInfos(SyncInfoSet infos) throws CVSException {
        final SyncInfoSet unadded= new SyncInfoSet();        
        for (final Iterator iter = infos.iterator(); iter.hasNext();) {
            final SyncInfo info = (SyncInfo) iter.next();
            final IResource resource= info.getLocal();
            if (!isAdded(resource))
                unadded.add(info);
        }
        return unadded;
    }
    
    private static SyncInfoSet getFiles(SyncInfoSet infos) throws CVSException {
        final SyncInfoSet files= new SyncInfoSet();        
        for (final Iterator iter = infos.iterator(); iter.hasNext();) {
            final SyncInfo info = (SyncInfo) iter.next();
            final IResource resource= info.getLocal();
            if (resource.getType() == IResource.FILE)
            	files.add(info);
        }
        return files;
    }
    
	private IResource[] getUnaddedResources(IResource[] resources) throws CVSException {
		List/*<IResource>*/ unadded = new ArrayList/*<IResource>*/();
		for (int i = 0; i < resources.length; i++) {
			if (!isAdded(resources[i])) {
				unadded.add(resources[i]);
			}
		}
		return (IResource[]) unadded.toArray(new IResource[0]);
	}

	private IResource[] getFiles(IResource[] resources) {
		final List files = new ArrayList();
		for (int i = 0; i < resources.length; i++) {
			if (resources[i].getType() == IResource.FILE)
				files.add(resources[i]);
		}
		return (IResource[]) files.toArray(new IResource[0]);
	}
	
    private static boolean isAdded(IResource resource) throws CVSException {
        final ICVSResource cvsResource = CVSWorkspaceRoot.getCVSResourceFor(resource);
        if (cvsResource.isFolder()) {




import java.util.Arrays;

import org.eclipse.compare.*;
import org.eclipse.compare.structuremergeviewer.IDiffElement;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.mapping.ResourceTraversal;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.dialogs.*;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.layout.GridLayoutFactory;

import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.widgets.*;
import org.eclipse.team.core.diff.*;
import org.eclipse.team.core.synchronize.SyncInfoSet;
import org.eclipse.team.internal.ccvs.ui.*;
import org.eclipse.team.internal.ccvs.ui.IHelpContextIds;
import org.eclipse.team.internal.ccvs.ui.mappings.ChangeSetComparator;
import org.eclipse.team.internal.core.subscribers.ActiveChangeSet;
import org.eclipse.team.internal.core.subscribers.ChangeSet;
import org.eclipse.team.internal.ui.*;
import org.eclipse.team.internal.ui.synchronize.SyncInfoModelElement;
import org.eclipse.team.internal.ui.synchronize.SynchronizePageConfiguration;
import org.eclipse.team.ui.synchronize.*;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.PageBook;

        fCommentArea.setProposedComment(getProposedComment(resources));
        if (resources.length > 0)
            fCommentArea.setProject(resources[0].getProject());
        fWizard.getDiffTree().addDiffChangeListener(new IDiffChangeListener() {
			public void propertyChanged(IDiffTree tree, int property, IPath[] paths) {
				// ignore property changes
			}
			public void diffsChanged(IDiffChangeEvent event, IProgressMonitor monitor) {
				Utils.syncExec(new Runnable() {
					public void run() {
						updateEnablements();
					}
				}, CommitWizardCommitPage.this.getControl());
			}
		});
    }
    
    /* (non-Javadoc)

    
    private void createChangesArea(Composite parent, PixelConverter converter) {
        
        ISynchronizeParticipant participant= fWizard.getParticipant();
        int size = fWizard.getDiffTree().getAffectedResources().length;
        if (size > getFileDisplayThreshold()) {
            // Create a page book to allow eventual inclusion of changes
            bottomChild = new PageBook(parent, SWT.NONE);

        ((Composite)getControl()).layout();
    }

    private Control createChangesPage(final Composite composite, ISynchronizeParticipant participant) {
        fConfiguration= participant.createPageConfiguration();
		CompareConfiguration cc = new CompareConfiguration();
		cc.setLeftEditable(false);

		return control;
    }
    
	private class CommitWizardParticipantPageCompareEditorInput extends
			ParticipantPageCompareEditorInput {
		public CommitWizardParticipantPageCompareEditorInput(
				CompareConfiguration cc,
				ISynchronizePageConfiguration configuration,
				ISynchronizeParticipant participant) {
			super(cc, configuration, participant);
		}

		protected boolean isOfferToRememberParticipant() {
			return false;
		}

		protected CompareViewerSwitchingPane createContentViewerSwitchingPane(
				Splitter parent, int style, CompareEditorInput cei) {
			return super.createContentViewerSwitchingPane(horizontalSash, style, cei);
		}

		protected void setPageDescription(String title) {
			super.setPageDescription(TeamUIMessages.ParticipantPageSaveablePart_0);
			pane.setText(TeamUIMessages.ParticipantPageSaveablePart_0);
			return pane;
		}
    }
    

            final Viewer viewer= fConfiguration.getPage().getViewer();
            viewer.refresh();
        }
        updateEnablements();
        setFocus();
    }

    protected void expand() {
        if (fConfiguration != null) {
            final Viewer viewer= fConfiguration.getPage().getViewer();

        	fHasConflicts = false;
        	fIsEmpty = false;
        	
			if (fWizard.hasConflicts()) {
    		if (set.hasConflicts()) {
    			fHasConflicts = true;
    		}
			if (!fWizard.hasOutgoingChanges()) {
    			fIsEmpty = true;
    		}
        }

    protected IWizardContainer getContainer() {
        return super.getContainer();
    }
    
    public SyncInfoSet getInfosToCommit() {

	ResourceTraversal[] getTraversalsToCommit() {
		return fWizard.getParticipant().getContext().getScope().getTraversals();
            return fWizard.getParticipant().getSyncInfoSet();
        }
        
        final IDiffElement root = (ISynchronizeModelElement)fConfiguration.getProperty(SynchronizePageConfiguration.P_MODEL);
        final IDiffElement [] elements= Utils.getDiffNodes(new IDiffElement [] { root });
        
        for (int i = 0; i < elements.length; i++) {
            if (elements[i] instanceof SyncInfoModelElement) {
                SyncInfo syncInfo = ((SyncInfoModelElement)elements[i]).getSyncInfo();
                int direction = syncInfo.getKind() & SyncInfo.DIRECTION_MASK;
				if (direction == SyncInfo.OUTGOING || direction == SyncInfo.CONFLICTING)
                	infos.add(syncInfo);
            }
        }  
        return infos;
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
     */




import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jface.action.*;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.operation.IRunnableContext;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.*;
import org.eclipse.swt.widgets.Display;
import org.eclipse.team.core.mapping.provider.SynchronizationContext;
import org.eclipse.team.internal.ccvs.ui.CVSDecoration;
import org.eclipse.team.internal.ccvs.ui.Policy;
import org.eclipse.team.internal.ccvs.ui.mappings.WorkspaceModelParticipant;
import org.eclipse.team.internal.ccvs.ui.subscriber.CVSParticipantLabelDecorator;
import org.eclipse.team.internal.ccvs.ui.subscriber.WorkspaceSynchronizeParticipant;
import org.eclipse.team.internal.ui.Utils;
import org.eclipse.team.internal.ui.synchronize.ChangeSetCapability;
import org.eclipse.team.internal.ui.synchronize.SynchronizePageConfiguration;
import org.eclipse.team.ui.mapping.SynchronizationActionProvider;
import org.eclipse.team.ui.synchronize.*;

/**
 * A participant that uses our decorator instead of the standard one.
 */
public class CommitWizardParticipant extends WorkspaceModelParticipant {
	
    /**
     * The actions to be displayed in the context menu.

    final CommitWizard fWizard;
	protected Action showComparePaneAction;
    
    public CommitWizardParticipant(SynchronizationContext context, CommitWizard wizard) {
        super(context);
        fWizard= wizard;
    }
    

    }
    
    public ChangeSetCapability getChangeSetCapability() {
		return super.getChangeSetCapability();
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.team.internal.ccvs.ui.subscriber.WorkspaceSynchronizeParticipant#initializeConfiguration(org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration)
     */
    protected void initializeConfiguration(final ISynchronizePageConfiguration configuration) {
        super.initializeConfiguration(configuration);
        configuration.setProperty(ISynchronizePageConfiguration.P_TOOLBAR_MENU, new String[] {ACTION_GROUP, ISynchronizePageConfiguration.NAVIGATE_GROUP});
        configuration.setProperty(ISynchronizePageConfiguration.P_CONTEXT_MENU, ISynchronizePageConfiguration.DEFAULT_CONTEXT_MENU);
		configuration.addMenuGroup(
				ISynchronizePageConfiguration.P_CONTEXT_MENU, 
				CONTEXT_MENU_CONTRIBUTION_GROUP_3);
        configuration.addActionContribution(new ActionContribution());

        // Wrap the container so that we can update the enablements after the runnable
        // (i.e. the container resets the state to what it was at the beginning of the
        // run even if the state of the page changed. Remove from View changes the state)

				ISelection selection = configuration.getSite().getSelectionProvider().getSelection();
				if(selection instanceof IStructuredSelection) {
					final Object obj = ((IStructuredSelection) selection).getFirstElement();
					if (fWizard.getParticipant().hasCompareInputFor(obj)) {
						fWizard.getCommitPage().showComparePane(true);
						showComparePaneAction.setChecked(true);
					}

    	IDialogSettings section = fWizard.getDialogSettings().getSection(CommitWizard.COMMIT_WIZARD_DIALOG_SETTINGS);
		return section == null ? false : section.getBoolean(CommitWizardCommitPage.SHOW_COMPARE);
    }

	protected ModelSynchronizeParticipantActionGroup createMergeActionGroup() {
		return new CommitWizardMergeActionGroup();
	}

	private class CommitWizardMergeActionGroup extends WorkspaceMergeActionGroup {
		protected void addToContextMenu(String mergeActionId, Action action, IMenuManager manager) {
			if (mergeActionId == SynchronizationActionProvider.MERGE_ACTION_ID
					|| mergeActionId == SynchronizationActionProvider.OVERWRITE_ACTION_ID
					|| mergeActionId == SynchronizationActionProvider.MARK_AS_MERGE_ACTION_ID) {
				// skip merge actions
				return;
			}
			super.addToContextMenu(mergeActionId, action, manager);
		}

		protected void appendToGroup(String menuId, String groupId,	IAction action) {
			if (menuId == ISynchronizePageConfiguration.P_CONTEXT_MENU
					&& groupId == WorkspaceModelParticipant.CONTEXT_MENU_COMMIT_GROUP_1) {
				// skip commit action
				return;
			}
			super.appendToGroup(menuId, groupId, action);
		}
	}
}

Return to bug 124039

Lines 15-22 Link Here

(-)src/org/eclipse/team/internal/ccvs/ui/wizards/CommitWizardCommitPage.java (-41 / +34 lines)
15	import java.util.Arrays;	15	import java.util.Arrays;
16		16
17	import org.eclipse.compare.*;	17	import org.eclipse.compare.*;
18	import org.eclipse.compare.structuremergeviewer.IDiffElement;
19	import org.eclipse.core.resources.IResource;	18	import org.eclipse.core.resources.IResource;
		19	import org.eclipse.core.resources.mapping.ResourceTraversal;
		20	import org.eclipse.core.runtime.IPath;
		21	import org.eclipse.core.runtime.IProgressMonitor;
20	import org.eclipse.jface.dialogs.*;	22	import org.eclipse.jface.dialogs.*;
21	import org.eclipse.jface.dialogs.Dialog;	23	import org.eclipse.jface.dialogs.Dialog;
22	import org.eclipse.jface.layout.GridLayoutFactory;	24	import org.eclipse.jface.layout.GridLayoutFactory;
Lines 33-48 Link Here
33	import org.eclipse.swt.events.SelectionEvent;	35	import org.eclipse.swt.events.SelectionEvent;
34	import org.eclipse.swt.layout.GridData;	36	import org.eclipse.swt.layout.GridData;
35	import org.eclipse.swt.widgets.*;	37	import org.eclipse.swt.widgets.*;
36	import org.eclipse.team.core.synchronize.SyncInfo;	38	import org.eclipse.team.core.diff.*;
37	import org.eclipse.team.core.synchronize.SyncInfoSet;
38	import org.eclipse.team.internal.ccvs.ui.*;	39	import org.eclipse.team.internal.ccvs.ui.*;
39	import org.eclipse.team.internal.ccvs.ui.IHelpContextIds;	40	import org.eclipse.team.internal.ccvs.ui.IHelpContextIds;
40	import org.eclipse.team.internal.ccvs.ui.mappings.ChangeSetComparator;	41	import org.eclipse.team.internal.ccvs.ui.mappings.ChangeSetComparator;
41	import org.eclipse.team.internal.core.subscribers.ActiveChangeSet;	42	import org.eclipse.team.internal.core.subscribers.ActiveChangeSet;
42	import org.eclipse.team.internal.core.subscribers.ChangeSet;	43	import org.eclipse.team.internal.core.subscribers.ChangeSet;
43	import org.eclipse.team.internal.ui.*;	44	import org.eclipse.team.internal.ui.*;
44	import org.eclipse.team.internal.ui.synchronize.SyncInfoModelElement;
45	import org.eclipse.team.internal.ui.synchronize.SynchronizePageConfiguration;
46	import org.eclipse.team.ui.synchronize.*;	45	import org.eclipse.team.ui.synchronize.*;
47	import org.eclipse.ui.PlatformUI;	46	import org.eclipse.ui.PlatformUI;
48	import org.eclipse.ui.part.PageBook;	47	import org.eclipse.ui.part.PageBook;
Lines 88-93 Link Here
88	fCommentArea.setProposedComment(getProposedComment(resources));	87	fCommentArea.setProposedComment(getProposedComment(resources));
89	if (resources.length > 0)	88	if (resources.length > 0)
90	fCommentArea.setProject(resources[0].getProject());	89	fCommentArea.setProject(resources[0].getProject());
		90	fWizard.getDiffTree().addDiffChangeListener(new IDiffChangeListener() {
		91	public void propertyChanged(IDiffTree tree, int property, IPath[] paths) {
		92	// ignore property changes
		93	}
		94	public void diffsChanged(IDiffChangeEvent event, IProgressMonitor monitor) {
		95	Utils.syncExec(new Runnable() {
		96	public void run() {
		97	updateEnablements();
		98	}
		99	}, CommitWizardCommitPage.this.getControl());
		100	}
		101	});
91	}	102	}
92		103
93	/* (non-Javadoc)	104	/* (non-Javadoc)
Lines 166-173 Link Here
166		177
167	private void createChangesArea(Composite parent, PixelConverter converter) {	178	private void createChangesArea(Composite parent, PixelConverter converter) {
168		179
169	CommitWizardParticipant participant= fWizard.getParticipant();	180	ISynchronizeParticipant participant= fWizard.getParticipant();
170	int size = participant.getSyncInfoSet().size();	181	int size = fWizard.getDiffTree().getAffectedResources().length;
171	if (size > getFileDisplayThreshold()) {	182	if (size > getFileDisplayThreshold()) {
172	// Create a page book to allow eventual inclusion of changes	183	// Create a page book to allow eventual inclusion of changes
173	bottomChild = new PageBook(parent, SWT.NONE);	184	bottomChild = new PageBook(parent, SWT.NONE);
Lines 203-209 Link Here
203	((Composite)getControl()).layout();	214	((Composite)getControl()).layout();
204	}	215	}
205		216
206	private Control createChangesPage(final Composite composite, CommitWizardParticipant participant) {	217	private Control createChangesPage(final Composite composite, ISynchronizeParticipant participant) {
207	fConfiguration= participant.createPageConfiguration();	218	fConfiguration= participant.createPageConfiguration();
208	CompareConfiguration cc = new CompareConfiguration();	219	CompareConfiguration cc = new CompareConfiguration();
209	cc.setLeftEditable(false);	220	cc.setLeftEditable(false);
Lines 214-240 Link Here
214	return control;	225	return control;
215	}	226	}
216		227
217	private class CommitWizardParticipantPageCompareEditorInput extends ParticipantPageCompareEditorInput {	228	private class CommitWizardParticipantPageCompareEditorInput extends
		229	ParticipantPageCompareEditorInput {
218	public CommitWizardParticipantPageCompareEditorInput(	230	public CommitWizardParticipantPageCompareEditorInput(
219	CompareConfiguration cc,	231	CompareConfiguration cc,
220	ISynchronizePageConfiguration configuration,	232	ISynchronizePageConfiguration configuration,
221	CommitWizardParticipant participant) {	233	ISynchronizeParticipant participant) {
222	super(cc, configuration, participant);	234	super(cc, configuration, participant);
223	}	235	}
224		236
225	protected boolean isOfferToRememberParticipant() {	237	protected boolean isOfferToRememberParticipant() {
226	return false;	238	return false;
227	}	239	}
228		240
229	protected CompareViewerSwitchingPane createContentViewerSwitchingPane(	241	protected CompareViewerSwitchingPane createContentViewerSwitchingPane(
230	Splitter parent, int style, CompareEditorInput cei) {	242	Splitter parent, int style, CompareEditorInput cei) {
231	return super.createContentViewerSwitchingPane(horizontalSash, style, cei);	243	return super.createContentViewerSwitchingPane(horizontalSash, style, cei);
232	}	244	}
233		245
234	protected CompareViewerPane createStructureInputPane(Composite parent) {	246	protected void setPageDescription(String title) {
235	CompareViewerPane pane = super.createStructureInputPane(parent);	247	super.setPageDescription(TeamUIMessages.ParticipantPageSaveablePart_0);
236	pane.setText(TeamUIMessages.ParticipantPageSaveablePart_0);
237	return pane;
238	}	248	}
239	}	249	}
240		250
Lines 292-300 Link Here
292	final Viewer viewer= fConfiguration.getPage().getViewer();	302	final Viewer viewer= fConfiguration.getPage().getViewer();
293	viewer.refresh();	303	viewer.refresh();
294	}	304	}
295	fCommentArea.setFocus();	305	updateEnablements();
		306	setFocus();
296	}	307	}
297		308
298	protected void expand() {	309	protected void expand() {
299	if (fConfiguration != null) {	310	if (fConfiguration != null) {
300	final Viewer viewer= fConfiguration.getPage().getViewer();	311	final Viewer viewer= fConfiguration.getPage().getViewer();
Lines 324-334 Link Here
324	fHasConflicts = false;	335	fHasConflicts = false;
325	fIsEmpty = false;	336	fIsEmpty = false;
326		337
327	SyncInfoSet set = fConfiguration.getSyncInfoSet();	338	if (fWizard.hasConflicts()) {
328	if (set.hasConflicts()) {
329	fHasConflicts = true;	339	fHasConflicts = true;
330	}	340	}
331	if (set.isEmpty()) {	341	if (!fWizard.hasOutgoingChanges()) {
332	fIsEmpty = true;	342	fIsEmpty = true;
333	}	343	}
334	}	344	}
Lines 373-400 Link Here
373	protected IWizardContainer getContainer() {	383	protected IWizardContainer getContainer() {
374	return super.getContainer();	384	return super.getContainer();
375	}	385	}
376
377	public SyncInfoSet getInfosToCommit() {
378		386
379	final SyncInfoSet infos= new SyncInfoSet();	387	ResourceTraversal[] getTraversalsToCommit() {
380	if (fConfiguration == null) {	388	return fWizard.getParticipant().getContext().getScope().getTraversals();
381	return fWizard.getParticipant().getSyncInfoSet();
382	}
383
384	final IDiffElement root = (ISynchronizeModelElement)fConfiguration.getProperty(SynchronizePageConfiguration.P_MODEL);
385	final IDiffElement [] elements= Utils.getDiffNodes(new IDiffElement [] { root });
386
387	for (int i = 0; i < elements.length; i++) {
388	if (elements[i] instanceof SyncInfoModelElement) {
389	SyncInfo syncInfo = ((SyncInfoModelElement)elements[i]).getSyncInfo();
390	int direction = syncInfo.getKind() & SyncInfo.DIRECTION_MASK;
391	if (direction == SyncInfo.OUTGOING \|\| direction == SyncInfo.CONFLICTING)
392	infos.add(syncInfo);
393	}
394	}
395	return infos;
396	}	389	}
397		390
398	/* (non-Javadoc)	391	/* (non-Javadoc)
399	* @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)	392	* @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent)
400	*/	393	*/

Lines 1-5 Link Here

(-)src/org/eclipse/team/internal/ccvs/ui/mappings/AbstractCommitAction.java (-3 / +3 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2009 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0	4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
Lines 78-84 Link Here
78		78
79	protected abstract ResourceTraversal[] getCommitTraversals(IStructuredSelection selection, IProgressMonitor monitor) throws CoreException;	79	protected abstract ResourceTraversal[] getCommitTraversals(IStructuredSelection selection, IProgressMonitor monitor) throws CoreException;
80		80
81	protected IResource[] getOutgoingChanges(final IResourceDiffTree tree, ResourceTraversal[] traversals, IProgressMonitor monitor) {	81	public static IResource[] getOutgoingChanges(final IResourceDiffTree tree, ResourceTraversal[] traversals, IProgressMonitor monitor) {
82	final List resources = new ArrayList();	82	final List resources = new ArrayList();
83	IDiff[] diffs = tree.getDiffs(traversals);	83	IDiff[] diffs = tree.getDiffs(traversals);
84	for (int i = 0; i < diffs.length; i++) {	84	for (int i = 0; i < diffs.length; i++) {
Lines 92-98 Link Here
92	return (IResource[]) resources.toArray(new IResource[resources.size()]);	92	return (IResource[]) resources.toArray(new IResource[resources.size()]);
93	}	93	}
94		94
95	private boolean hasLocalChange(IDiff diff) {	95	public static boolean hasLocalChange(IDiff diff) {
96	if (diff instanceof IThreeWayDiff) {	96	if (diff instanceof IThreeWayDiff) {
97	IThreeWayDiff twd = (IThreeWayDiff) diff;	97	IThreeWayDiff twd = (IThreeWayDiff) diff;
98	return twd.getDirection() == IThreeWayDiff.OUTGOING	98	return twd.getDirection() == IThreeWayDiff.OUTGOING

Lines 16-39 Link Here

(-)src/org/eclipse/team/internal/ccvs/ui/wizards/CommitWizardParticipant.java (-11 / +39 lines)
16	import org.eclipse.core.resources.IFile;	16	import org.eclipse.core.resources.IFile;
17	import org.eclipse.core.resources.IResource;	17	import org.eclipse.core.resources.IResource;
18	import org.eclipse.core.runtime.CoreException;	18	import org.eclipse.core.runtime.CoreException;
19	import org.eclipse.jface.action.Action;	19	import org.eclipse.jface.action.*;
20	import org.eclipse.jface.dialogs.IDialogSettings;	20	import org.eclipse.jface.dialogs.IDialogSettings;
21	import org.eclipse.jface.operation.IRunnableContext;	21	import org.eclipse.jface.operation.IRunnableContext;
22	import org.eclipse.jface.operation.IRunnableWithProgress;	22	import org.eclipse.jface.operation.IRunnableWithProgress;
23	import org.eclipse.jface.viewers.*;	23	import org.eclipse.jface.viewers.*;
24	import org.eclipse.swt.widgets.Display;	24	import org.eclipse.swt.widgets.Display;
		25	import org.eclipse.team.core.mapping.provider.SynchronizationContext;
25	import org.eclipse.team.internal.ccvs.ui.CVSDecoration;	26	import org.eclipse.team.internal.ccvs.ui.CVSDecoration;
26	import org.eclipse.team.internal.ccvs.ui.Policy;	27	import org.eclipse.team.internal.ccvs.ui.Policy;
		28	import org.eclipse.team.internal.ccvs.ui.mappings.WorkspaceModelParticipant;
27	import org.eclipse.team.internal.ccvs.ui.subscriber.CVSParticipantLabelDecorator;	29	import org.eclipse.team.internal.ccvs.ui.subscriber.CVSParticipantLabelDecorator;
28	import org.eclipse.team.internal.ccvs.ui.subscriber.WorkspaceSynchronizeParticipant;
29	import org.eclipse.team.internal.ui.Utils;	30	import org.eclipse.team.internal.ui.Utils;
30	import org.eclipse.team.internal.ui.synchronize.*;	31	import org.eclipse.team.internal.ui.synchronize.ChangeSetCapability;
		32	import org.eclipse.team.internal.ui.synchronize.SynchronizePageConfiguration;
		33	import org.eclipse.team.ui.mapping.SynchronizationActionProvider;
31	import org.eclipse.team.ui.synchronize.*;	34	import org.eclipse.team.ui.synchronize.*;
32		35
33	/**	36	/**
34	* A participant that uses our decorator instead of the standard one.	37	* A participant that uses our decorator instead of the standard one.
35	*/	38	*/
36	public class CommitWizardParticipant extends WorkspaceSynchronizeParticipant {	39	public class CommitWizardParticipant extends WorkspaceModelParticipant {
37		40
38	/**	41	/**
39	* The actions to be displayed in the context menu.	42	* The actions to be displayed in the context menu.
Lines 79-86 Link Here
79	final CommitWizard fWizard;	82	final CommitWizard fWizard;
80	protected Action showComparePaneAction;	83	protected Action showComparePaneAction;
81		84
82	public CommitWizardParticipant(ISynchronizeScope scope, CommitWizard wizard) {	85	public CommitWizardParticipant(SynchronizationContext context, CommitWizard wizard) {
83	super(scope);	86	super(context);
84	fWizard= wizard;	87	fWizard= wizard;
85	}	88	}
86		89
Lines 89-109 Link Here
89	}	92	}
90		93
91	public ChangeSetCapability getChangeSetCapability() {	94	public ChangeSetCapability getChangeSetCapability() {
92	return null; // we don't want that button	95	return super.getChangeSetCapability();
93	}	96	}
94		97
95	/* (non-Javadoc)	98	/* (non-Javadoc)
96	* @see org.eclipse.team.internal.ccvs.ui.subscriber.WorkspaceSynchronizeParticipant#initializeConfiguration(org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration)	99	* @see org.eclipse.team.internal.ccvs.ui.subscriber.WorkspaceSynchronizeParticipant#initializeConfiguration(org.eclipse.team.ui.synchronize.ISynchronizePageConfiguration)
97	*/	100	*/
98	protected void initializeConfiguration( final ISynchronizePageConfiguration configuration) {	101	protected void initializeConfiguration(final ISynchronizePageConfiguration configuration) {
99	super.initializeConfiguration(configuration);	102	super.initializeConfiguration(configuration);
100	configuration.setProperty(ISynchronizePageConfiguration.P_TOOLBAR_MENU, new String[] {ACTION_GROUP, ISynchronizePageConfiguration.LAYOUT_GROUP});	103	configuration.setProperty(ISynchronizePageConfiguration.P_TOOLBAR_MENU, new String[] {ACTION_GROUP, ISynchronizePageConfiguration.NAVIGATE_GROUP});
101	configuration.setProperty(ISynchronizePageConfiguration.P_CONTEXT_MENU, ISynchronizePageConfiguration.DEFAULT_CONTEXT_MENU);	104	configuration.setProperty(ISynchronizePageConfiguration.P_CONTEXT_MENU, ISynchronizePageConfiguration.DEFAULT_CONTEXT_MENU);
102	configuration.addMenuGroup(	105	configuration.addMenuGroup(
103	ISynchronizePageConfiguration.P_CONTEXT_MENU,	106	ISynchronizePageConfiguration.P_CONTEXT_MENU,
104	CONTEXT_MENU_CONTRIBUTION_GROUP_3);	107	CONTEXT_MENU_CONTRIBUTION_GROUP_3);
105	configuration.addActionContribution(new ActionContribution());	108	configuration.addActionContribution(new ActionContribution());
106		109
107	// Wrap the container so that we can update the enablements after the runnable	110	// Wrap the container so that we can update the enablements after the runnable
108	// (i.e. the container resets the state to what it was at the beginning of the	111	// (i.e. the container resets the state to what it was at the beginning of the
109	// run even if the state of the page changed. Remove from View changes the state)	112	// run even if the state of the page changed. Remove from View changes the state)
Lines 137-143 Link Here
137	ISelection selection = configuration.getSite().getSelectionProvider().getSelection();	140	ISelection selection = configuration.getSite().getSelectionProvider().getSelection();
138	if(selection instanceof IStructuredSelection) {	141	if(selection instanceof IStructuredSelection) {
139	final Object obj = ((IStructuredSelection) selection).getFirstElement();	142	final Object obj = ((IStructuredSelection) selection).getFirstElement();
140	if (obj instanceof SyncInfoModelElement) {	143	if (fWizard.getParticipant().hasCompareInputFor(obj)) {
141	fWizard.getCommitPage().showComparePane(true);	144	fWizard.getCommitPage().showComparePane(true);
142	showComparePaneAction.setChecked(true);	145	showComparePaneAction.setChecked(true);
143	}	146	}
Lines 157-160 Link Here
157	IDialogSettings section = fWizard.getDialogSettings().getSection(CommitWizard.COMMIT_WIZARD_DIALOG_SETTINGS);	160	IDialogSettings section = fWizard.getDialogSettings().getSection(CommitWizard.COMMIT_WIZARD_DIALOG_SETTINGS);
158	return section == null ? false : section.getBoolean(CommitWizardCommitPage.SHOW_COMPARE);	161	return section == null ? false : section.getBoolean(CommitWizardCommitPage.SHOW_COMPARE);
159	}	162	}
		163
		164	protected ModelSynchronizeParticipantActionGroup createMergeActionGroup() {
		165	return new CommitWizardMergeActionGroup();
		166	}
		167
		168	private class CommitWizardMergeActionGroup extends WorkspaceMergeActionGroup {
		169	protected void addToContextMenu(String mergeActionId, Action action, IMenuManager manager) {
		170	if (mergeActionId == SynchronizationActionProvider.MERGE_ACTION_ID
		171	\|\| mergeActionId == SynchronizationActionProvider.OVERWRITE_ACTION_ID
		172	\|\| mergeActionId == SynchronizationActionProvider.MARK_AS_MERGE_ACTION_ID) {
		173	// skip merge actions
		174	return;
		175	}
		176	super.addToContextMenu(mergeActionId, action, manager);
		177	}
		178
		179	protected void appendToGroup(String menuId, String groupId, IAction action) {
		180	if (menuId == ISynchronizePageConfiguration.P_CONTEXT_MENU
		181	&& groupId == WorkspaceModelParticipant.CONTEXT_MENU_COMMIT_GROUP_1) {
		182	// skip commit action
		183	return;
		184	}
		185	super.appendToGroup(menuId, groupId, action);
		186	}
		187	}
160	}	188	}