Attachment #176219 for bug #273450

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




package org.eclipse.compare; 

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.ResourceBundle;

import org.eclipse.compare.contentmergeviewer.ContentMergeViewer;
import org.eclipse.compare.contentmergeviewer.IFlushable;
import org.eclipse.compare.internal.BinaryCompareViewer;
import org.eclipse.compare.internal.ChangePropertyAction;

import org.eclipse.compare.internal.CompareStructureViewerSwitchingPane;
import org.eclipse.compare.internal.CompareUIPlugin;
import org.eclipse.compare.internal.ICompareUIConstants;
import org.eclipse.compare.internal.IFlushable2;
import org.eclipse.compare.internal.OutlineViewerCreator;
import org.eclipse.compare.internal.Utilities;
import org.eclipse.compare.internal.ViewerDescriptor;

	 * @since 3.3
	 */
	public static final String PROP_SELECTED_EDITION= ICompareUIConstants.PROP_SELECTED_EDITION;

	private static final String COMPARE_EDITOR_IMAGE_NAME= "eview16/compare_view.gif"; //$NON-NLS-1$
	private static Image fgTitleImage;
	

	private String fTitle;
	private ListenerList fListenerList= new ListenerList();
	private CompareNavigator fNavigator;
	private ContentMergeViewer fLeftDirtyViewer = null;
	private ContentMergeViewer fRightDirtyViewer = null;
	private IPropertyChangeListener fDirtyStateListener;
	
	boolean fStructureCompareOnSingleClick= true;

	}
	
	/**
	 * Returns <code>true</code> if there are unsaved changes in either left or
	 * right side. The value returned is the value of the
	 * <code>DIRTY_STATE</code> property of this input object.
	 * 
	 * Returns <code>true</code> if left or right side has unsaved changes
	 * Subclasses don't have to override if the functionality provided by
	 * <code>setDirty</code> is sufficient.
	 * 
	 * @return <code>true</code> if there are changes that need to be saved
	 */
	public boolean isSaveNeeded() {
		return isLeftSaveNeeded() || isRightSaveNeeded();
	}

	/**
	 * Returns <code>true</code> if there are unsaved changes for left side.
	 * 
	 * @return <code>true</code> if there are changes that need to be saved
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean isLeftSaveNeeded() {
		return fLeftDirtyViewer != null;
	}

	/**
	 * Returns <code>true</code> if there are unsaved changes for right side.
	 * 
	 * @return <code>true</code> if there are changes that need to be saved
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected boolean isRightSaveNeeded() {
		return fRightDirtyViewer != null;
	}
	
	/**

	}
		
	/**
	 * Sets the dirty state of this input to the given value and sends out a
	 * <code>PropertyChangeEvent</code> if the new value differs from the old
	 * value. Direct calling this method with parameter dirty equal to
	 * <code>false</code> when there are unsaved changes in viewers, results in
	 * inconsistent state. The dirty state of compare input should be based only
	 * on the information if there are changes in viewers for left or right
	 * side.
	 * 
	 * @param dirty
	 *            the dirty state for this compare input
	 */
	public void setDirty(boolean dirty) {
		boolean oldDirty = isSaveNeeded();
		boolean newDirty = dirty || isSaveNeeded();
		if (!newDirty) {
			fLeftDirtyViewer = null;
			fRightDirtyViewer = null;
		}
		if (oldDirty != isSaveNeeded()) {
			Utilities.firePropertyChange(fListenerList, this, DIRTY_STATE, Boolean.valueOf(oldDirty), Boolean.valueOf(isSaveNeeded()));
		}
	}
	
	/**
	 * Method adds or removes viewers that changed left or right side of this
	 * compare input. Any modification of any of the list of viewers may result
	 * in dirty state change.
	 * 
	 * @param source
	 *            the object that fired <code>PropertyChangeEvent</code>
	 *            modifying the dirty state
	 * @param dirty
	 *            value that describes if the changes were added or removed
	 */
	private void setDirty(Object source, boolean dirty) {
		Assert.isNotNull(source);
		boolean oldDirty = isSaveNeeded();
		ContentMergeViewer cmv = (ContentMergeViewer) source;
		if (dirty) {
			if (cmv.internalIsLeftDirty()) {
				if (fLeftDirtyViewer == null) {
					fLeftDirtyViewer = cmv;
				}
			}
			if (cmv.internalIsRightDirty()) {
				if (fRightDirtyViewer == null) {
					fRightDirtyViewer = cmv;
				}
			}
		} else {
			if (!cmv.internalIsLeftDirty()) {
				fLeftDirtyViewer = null;
			}
			if (!cmv.internalIsRightDirty()) {
				fRightDirtyViewer = null;
			}
		}
		boolean newDirty = isSaveNeeded();
		if (DEBUG) {
			System.out.println("setDirty(" + source + ", " + dirty + "): " + newDirty); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		}
		if (oldDirty != newDirty) {
			Utilities.firePropertyChange(fListenerList, this, DIRTY_STATE, Boolean.valueOf(oldDirty), Boolean.valueOf(newDirty));
		}
	}
	
	/* (non Javadoc)

		flushViewer(fStructurePane2, monitor);
		flushViewer(fContentInputPane, monitor);
	}
	
	/**
	 * @param monitor
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected void flushLeftViewers(IProgressMonitor monitor) {
		// flush changes in left dirty viewer
		flushViewer(fStructureInputPane, monitor);
		flushViewer(fStructurePane1, monitor);
		flushViewer(fStructurePane2, monitor);
		flushLeftViewer(fContentInputPane, monitor);
	}

	/**
	 * @param monitor
	 * @noreference This method is not intended to be referenced by clients.
	 */
	protected void flushRightViewers(IProgressMonitor monitor) {
		// flush changes in right dirty viewer
		flushViewer(fStructureInputPane, monitor);
		flushViewer(fStructurePane1, monitor);
		flushViewer(fStructurePane2, monitor);
		flushRightViewer(fContentInputPane, monitor);
	}
	
	private static void flushViewer(CompareViewerPane pane, IProgressMonitor pm) {
		if (pane != null) {
			IFlushable flushable = (IFlushable)Utilities.getAdapter(pane, IFlushable.class);

		}
	}
	
	private static void flushLeftViewer(CompareViewerPane pane, IProgressMonitor pm) {
		if (pane != null) {
			IFlushable2 flushable = (IFlushable2)Utilities.getAdapter(pane, IFlushable2.class);
			if (flushable != null)
				flushable.flushLeft(pm);
		}
	}

	private static void flushRightViewer(CompareViewerPane pane, IProgressMonitor pm) {
		if (pane != null) {
			IFlushable2 flushable = (IFlushable2)Utilities.getAdapter(pane, IFlushable2.class);
			if (flushable != null)
				flushable.flushRight(pm);
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.compare.ICompareContainer#addCompareInputChangeListener(org.eclipse.compare.structuremergeviewer.ICompareInput, org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener)
	 */

Lines 12-17 Link Here

(-)compare/org/eclipse/compare/CompareViewerSwitchingPane.java (+9 lines)
12		12
13	import org.eclipse.compare.contentmergeviewer.IFlushable;	13	import org.eclipse.compare.contentmergeviewer.IFlushable;
14	import org.eclipse.compare.internal.CompareMessages;	14	import org.eclipse.compare.internal.CompareMessages;
		15	import org.eclipse.compare.internal.IFlushable2;
15	import org.eclipse.compare.internal.NullViewer;	16	import org.eclipse.compare.internal.NullViewer;
16	import org.eclipse.compare.internal.Utilities;	17	import org.eclipse.compare.internal.Utilities;
17	import org.eclipse.compare.structuremergeviewer.ICompareInput;	18	import org.eclipse.compare.structuremergeviewer.ICompareInput;
Lines 354-359 Link Here
354	return flushable;	355	return flushable;
355	}	356	}
356	}	357	}
		358	if (adapter == IFlushable2.class) {
		359	Viewer v= getViewer();
		360	if (v != null) {
		361	IFlushable2 flushable = (IFlushable2)Utilities.getAdapter(v, IFlushable2.class);
		362	if (flushable != null)
		363	return flushable;
		364	}
		365	}
357	return super.getAdapter(adapter);	366	return super.getAdapter(adapter);
358	}	367	}
359		368




import org.eclipse.compare.internal.CompareHandlerService;
import org.eclipse.compare.internal.CompareMessages;
import org.eclipse.compare.internal.ICompareUIConstants;
import org.eclipse.compare.internal.IFlushable2;
import org.eclipse.compare.internal.ISavingSaveable;
import org.eclipse.compare.internal.MergeViewerContentProvider;
import org.eclipse.compare.internal.Utilities;
import org.eclipse.compare.internal.ViewerSwitchingCancelled;
import org.eclipse.compare.structuremergeviewer.Differencer;
import org.eclipse.compare.structuremergeviewer.ICompareInput;
import org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.commands.IExecutionListener;
import org.eclipse.core.commands.NotHandledException;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.swt.widgets.Layout;
import org.eclipse.swt.widgets.Sash;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.ui.ISaveablesSource;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.Saveable;

/**
 * An abstract compare and merge viewer with two side-by-side content areas

 * @see TextMergeViewer
 */
public abstract class ContentMergeViewer extends ContentViewer
					implements IPropertyChangeNotifier, IFlushable, IFlushable2 {
	
	/* package */ static final int HORIZONTAL= 1;
	/* package */ static final int VERTICAL= 2;

	private boolean fIsLeftDirty;
	private boolean fIsRightDirty;

	private boolean fIsSaving;
	private ICommandService fCommandService;
	private IExecutionListener fExecutionListener;
	
	private CompareHandlerService fHandlerService;

	// SWT widgets

		
		fIsLeftDirty = false;
		fIsRightDirty = false;

		fIsSaving = false;
		fCommandService = (ICommandService)PlatformUI.getWorkbench().getAdapter(ICommandService.class);
		if (fCommandService != null) {
			fCommandService.addExecutionListener(getExecutionListener());
		}
	}

	private IExecutionListener getExecutionListener() {
		if (fExecutionListener == null) {
			fExecutionListener = new IExecutionListener() {
				public void preExecute(String commandId, ExecutionEvent event) {
					if (IWorkbenchCommandConstants.FILE_SAVE.equals(commandId)
							|| IWorkbenchCommandConstants.FILE_SAVE_ALL.equals(commandId))
						fIsSaving = true;
				}

				public void postExecuteSuccess(String commandId, Object returnValue) {
					if (IWorkbenchCommandConstants.FILE_SAVE.equals(commandId)
							|| IWorkbenchCommandConstants.FILE_SAVE_ALL.equals(commandId))
						fIsSaving= false;
				}

				public void postExecuteFailure(String commandId, ExecutionException exception) {
					if (IWorkbenchCommandConstants.FILE_SAVE.equals(commandId)
							|| IWorkbenchCommandConstants.FILE_SAVE_ALL.equals(commandId))
						fIsSaving= false;
				}

				public void notHandled(String commandId, NotHandledException exception) {
					// not needed
				}
			};
		}
		return fExecutionListener;
	}
	
	//---- hooks ---------------------
	
	/**

			fHVSashCursor= null;
		}
		
		if (fCommandService != null) {
			fCommandService.removeExecutionListener(fExecutionListener);
			fCommandService = null;
			fExecutionListener = null;
		}

		super.handleDispose(event);
  	}
  	

	protected void setLeftDirty(boolean dirty) {
		if (isLeftDirty() != dirty) {
			fIsLeftDirty = dirty;
			// Always fire the event if the dirty state has changed
			fireDirtyState(dirty);
				fireDirtyState(dirty);
		}
	}
	

	protected void setRightDirty(boolean dirty) {
		if (isRightDirty() != dirty) {
			fIsRightDirty = dirty;
			// Always fire the event if the dirty state has changed
			fireDirtyState(dirty);
				fireDirtyState(dirty);
		}
	}
	

	public final void flush(IProgressMonitor monitor) {
		flushContent(getInput(), monitor);
	}

	/**
	 * Flush the modified content back to input elements via the content provider.
	 * The provided input may be the current input of the viewer or it may be

	 * @since 3.3
	 */
	protected void flushContent(Object input, IProgressMonitor monitor) {
		flushLeftSide(input, monitor);
		flushRightSide(input, monitor);
	}


	void flushLeftSide(Object input, IProgressMonitor monitor) {
		IMergeViewerContentProvider content = (IMergeViewerContentProvider) getContentProvider();

		boolean rightEmpty = content.getRightContent(input) == null;

		if (getCompareConfiguration().isLeftEditable() && isLeftDirty()) {
			byte[] bytes = getContents(true);
			if (rightEmpty && bytes != null && bytes.length == 0)
				bytes = null;
			setLeftDirty(false);
			content.saveLeftContent(input, bytes);
		}
	}

	void flushRightSide(Object input, IProgressMonitor monitor) {
		IMergeViewerContentProvider content = (IMergeViewerContentProvider) getContentProvider();

		boolean leftEmpty = content.getLeftContent(input) == null;

		if (getCompareConfiguration().isRightEditable() && isRightDirty()) {
			byte[] bytes = getContents(false);
			if (leftEmpty && bytes != null && bytes.length == 0)
				bytes = null;
			setRightDirty(false);
			content.saveRightContent(input, bytes);
		}
	}

	/**
	 * @param monitor
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public void flushLeft(IProgressMonitor monitor) {
		flushLeftSide(getInput(), monitor);
	}

	/**
	 * @param monitor
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public void flushRight(IProgressMonitor monitor) {
		flushRightSide(getInput(), monitor);
	}

	/**
	 * Return the dirty state of the right side of this viewer.
	 * @return the dirty state of the right side of this viewer
	 * @since 3.3

	}

	/**
	 * @return the dirty state of the right side of this viewer
	 * @since 3.7
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public boolean internalIsRightDirty() {
		return isRightDirty();
	}

	/**
	 * Return the dirty state of the left side of this viewer.
	 * @return the dirty state of the left side of this viewer
	 * @since 3.3

	}

	/**
	 * @return the dirty state of the left side of this viewer
	 * @since 3.7
	 * @noreference This method is not intended to be referenced by clients.
	 */
	public boolean internalIsLeftDirty() {
		return isLeftDirty();
	}

	/**
	 * Handle a change to the given input reported from an {@link org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener}.
	 * This class registers a listener with its input and reports any change events through
	 * this method. By default, this method prompts for any unsaved changes and then refreshes

	protected void handleCompareInputChange() {
		// before setting the new input we have to save the old
		Object input = getInput();
		if (!isSaving() && (isLeftDirty() || isRightDirty())) {
			
			if (Utilities.RUNNING_TESTS) {
				if (Utilities.TESTING_FLUSH_ON_COMPARE_INPUT_CHANGE) {

					break;
				}
			}
			refresh();
		}
		refresh();
	}

	CompareHandlerService getCompareHandlerService() {
		return fHandlerService;
	}

	/**
	 * @return true if any of the Saveables is being saved
	 */
	private boolean isSaving() {
		ICompareContainer container = fCompareConfiguration.getContainer();
		ISaveablesSource source = null;
		if (container instanceof ISaveablesSource) {
			source = (ISaveablesSource) container;
		} else {
			IWorkbenchPart part = container.getWorkbenchPart();
			if (part instanceof ISaveablesSource) {
				source = (ISaveablesSource) part;
			}
		}
		if (source != null) {
			Saveable[] saveables = source.getSaveables();
			for (int i = 0; i < saveables.length; i++) {
				if (saveables[i] instanceof ISavingSaveable) {
					ISavingSaveable saveable = (ISavingSaveable) saveables[i];
					if (saveable.isSaving())
						return true;
				}
			}
		}
		return false;
	} 

}




		return fMerger.virtualToRealPosition(contributor, v);
	}
	
	void flushLeftSide(Object oldInput, IProgressMonitor monitor){
	 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#flushContent(java.lang.Object, org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected void flushContent(Object oldInput, IProgressMonitor monitor) {
				
		// check and handle any shared buffers
		IMergeViewerContentProvider content= getMergeContentProvider();
		Object leftContent = content.getLeftContent(oldInput);
		Object rightContent = content.getRightContent(oldInput);
		
		if (leftContent != null && getCompareConfiguration().isLeftEditable() && isLeftDirty()) {
			if (fLeftContributor.hasSharedDocument(leftContent)) {

			}
		}
		
		if (!(content instanceof MergeViewerContentProvider) || isLeftDirty()) {
			super.flushLeftSide(oldInput, monitor);
		}
	}
	
	void flushRightSide(Object oldInput, IProgressMonitor monitor){
		IMergeViewerContentProvider content= getMergeContentProvider();
		Object rightContent = content.getRightContent(oldInput);
		
		if (rightContent != null && getCompareConfiguration().isRightEditable() && isRightDirty()) {
			if (fRightContributor.hasSharedDocument(rightContent)) {
				if (flush(fRightContributor))
					setRightDirty(false);
			}
		}

		if (!(content instanceof MergeViewerContentProvider) || isRightDirty()) {
			super.flushRightSide(oldInput, monitor);
		}
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#flushContent(java.lang.Object, org.eclipse.core.runtime.IProgressMonitor)
	 */
	protected void flushContent(Object oldInput, IProgressMonitor monitor) {
		flushLeftSide(oldInput, monitor);
		flushRightSide(oldInput, monitor);

		IMergeViewerContentProvider content = getMergeContentProvider();

		if (!(content instanceof MergeViewerContentProvider) || isLeftDirty() || isRightDirty()) {
			super.flushContent(oldInput, monitor);
		}




/*******************************************************************************
 * 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.compare.internal;

import org.eclipse.compare.contentmergeviewer.IFlushable;
import org.eclipse.core.runtime.IProgressMonitor;

/**
 * Interface which provides the ability to flush the contents from the specified
 * side of the viewer.
 * 
 * @see IFlushable
 * 
 * @since 3.7
 */
public interface IFlushable2 {
	void flushLeft(IProgressMonitor monitor);

	void flushRight(IProgressMonitor monitor);
}




/*******************************************************************************
 * 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.compare.internal;

import org.eclipse.ui.Saveable;

/**
 * Interface defines API for checking if an object, preferably an instance of
 * {@link Saveable}, is being saved.
 * 
 * @since 3.7
 */
public interface ISavingSaveable {
	public boolean isSaving();
}

Lines 1-5 Link Here

(-)src/org/eclipse/compare/tests/ContentMergeViewerTest.java (-5 / +12 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2008 IBM Corporation and others.	2	* Copyright (c) 2008, 2010 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 21-26 Link Here
21	public class ContentMergeViewerTest extends TestCase {	21	public class ContentMergeViewerTest extends TestCase {
22		22
23	private MyContentMergeViewer myContentMergeViewer;	23	private MyContentMergeViewer myContentMergeViewer;
		24	/**
		25	* result[0]-event occurred or not; result[1]-new state that was set
		26	*/
24	boolean[] result = new boolean[] { false, false };	27	boolean[] result = new boolean[] { false, false };
25		28
26	public ContentMergeViewerTest() {	29	public ContentMergeViewerTest() {
Lines 109-115 Link Here
109	myContentMergeViewer.rightDirty = true;	112	myContentMergeViewer.rightDirty = true;
110	myContentMergeViewer.setLeftDirty(true);	113	myContentMergeViewer.setLeftDirty(true);
111		114
112	Assert.assertEquals(false, result[0]);	115	Assert.assertEquals(true, result[0]);
		116	Assert.assertEquals(true, result[1]);
113	}	117	}
114		118
115	public void testTFTX() {	119	public void testTFTX() {
Lines 160-166 Link Here
160	myContentMergeViewer.rightDirty = true;	164	myContentMergeViewer.rightDirty = true;
161	myContentMergeViewer.setLeftDirty(false);	165	myContentMergeViewer.setLeftDirty(false);
162		166
163	Assert.assertEquals(false, result[0]);	167	Assert.assertEquals(true, result[0]);
		168	Assert.assertEquals(false, result[1]);
164	}	169	}
165		170
166	// set right to true	171	// set right to true
Lines 187-193 Link Here
187	myContentMergeViewer.rightDirty = false;	192	myContentMergeViewer.rightDirty = false;
188	myContentMergeViewer.setRightDirty(true);	193	myContentMergeViewer.setRightDirty(true);
189		194
190	Assert.assertEquals(false, result[0]);	195	Assert.assertEquals(true, result[0]);
		196	Assert.assertEquals(true, result[1]);
191	}	197	}
192		198
193	public void testTTXT() {	199	public void testTTXT() {
Lines 230-235 Link Here
230	myContentMergeViewer.rightDirty = true;	236	myContentMergeViewer.rightDirty = true;
231	myContentMergeViewer.setRightDirty(false);	237	myContentMergeViewer.setRightDirty(false);
232		238
233	Assert.assertEquals(false, result[0]);	239	Assert.assertEquals(true, result[0]);
		240	Assert.assertEquals(false, result[1]);
234	}	241	}
235	}	242	}




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

package org.eclipse.team.internal.ui.synchronize;

import org.eclipse.compare.*;
import org.eclipse.compare.internal.ISavingSaveable;
import org.eclipse.compare.structuremergeviewer.ICompareInput;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.*;

 * @see LocalResourceTypedElement
 * @since 3.3
 */
public abstract class LocalResourceSaveableComparison extends SaveableComparison implements IPropertyChangeListener, ISavingSaveable {

	private final ICompareInput input;
	private final CompareEditorInput editorInput;

			flushViewers(Policy.subMonitorFor(monitor, 40));
			// Then we tell the input to commit its changes
			// Only the left is ever saveable
			ITypedElement te = getFileElement();
			if (te instanceof LocalResourceTypedElement) {
				LocalResourceTypedElement lrte = (LocalResourceTypedElement) te;
				lrte.commit(Policy.subMonitorFor(monitor, 60));
			}
		} finally {
			// Make sure we fire a change for the compare input to update the viewers

	 * @throws CoreException
	 */
	protected void flushViewers(IProgressMonitor monitor) throws CoreException {
		if (editorInput instanceof SaveablesCompareEditorInput) {
			((SaveablesCompareEditorInput) editorInput).saveChanges(monitor, this);
		} else {
			editorInput.saveChanges(monitor);
		}
	}

	/**

	public boolean isDirty() {
		// We need to get the dirty state from the compare editor input
		// since it is our only connection to the merge viewer
		if (editorInput instanceof SaveablesCompareEditorInput) {
			return ((SaveablesCompareEditorInput) editorInput).isSaveNeeded(this);
		}
		return editorInput.isSaveNeeded();
	}
	

	 * @see org.eclipse.ui.Saveable#getName()
	 */
	public String getName() {
		// Return the name of the file element as held in the compare input
		if (fileElement.equals(input.getLeft())) {
			return input.getLeft().getName();
		}
		if (fileElement.equals(input.getRight())) {
			return input.getRight().getName();
		}
		// Fallback call returning name of the main non-null element of the input
		// see org.eclipse.team.internal.ui.mapping.AbstractCompareInput#getMainElement()
		return input.getName();
	}


		}
		return false;
	}

	public boolean isSaving() {
		return isSaving;
	}
}




						closed = closeEditor(true);
					}
					if (!closed) {
						// The editor was not closed either because the compare
						// input still has changes or because the editor input
						// is dirty. In either case, fire the changes
						// fire the changes
						// to the registered listeners
						propogateInputChange();
					}

	}

	/**
	 * Returns <code>true</code> if the given saveable contains any unsaved
	 * changes. If the saveable doesn't match either left nor right side of the
	 * current editor input {@link CompareEditorInput#isSaveNeeded()} is called.
	 * <p>
	 * This method is preferred to {@link CompareEditorInput#isSaveNeeded()}.
	 * 
	 * @param the
	 *            the saveable to check
	 * @return <code>true</code> if there are changes that need to be saved
	 * @since 3.7
	 */
	boolean isSaveNeeded(Saveable saveable) {
		if (saveable == null) {
			return isSaveNeeded();
		}
		if (saveable.equals(fLeftSaveable)) {
			return isLeftSaveNeeded();
		}
		if (saveable.equals(fRightSaveable)) {
			return isRightSaveNeeded();
		}
		// Fallback call returning true if there are unsaved changes in either
		// left or right side
		return isSaveNeeded();
	}

	void saveChanges(IProgressMonitor monitor, Saveable saveable)
			throws CoreException {
		if (saveable.equals(fLeftSaveable)) {
			flushLeftViewers(monitor);
			return;
		} else if (saveable.equals(fRightSaveable)) {
			flushRightViewers(monitor);
			return;
		}
		Assert.isTrue(false, "invalid saveable parameter"); //$NON-NLS-1$
	}

	/**
	 * Close the editor if it is not dirty. If it is still dirty, let the
	 * content merge viewer handle the compare input change.
	 * 

Return to bug 273450

Lines 4838-4852 Link Here

(-)compare/org/eclipse/compare/contentmergeviewer/TextMergeViewer.java (-8 / +25 lines)
4838	return fMerger.virtualToRealPosition(contributor, v);	4838	return fMerger.virtualToRealPosition(contributor, v);
4839	}	4839	}
4840		4840
4841	/* (non-Javadoc)	4841	void flushLeftSide(Object oldInput, IProgressMonitor monitor){
4842	* @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#flushContent(java.lang.Object, org.eclipse.core.runtime.IProgressMonitor)
4843	*/
4844	protected void flushContent(Object oldInput, IProgressMonitor monitor) {
4845
4846	// check and handle any shared buffers
4847	IMergeViewerContentProvider content= getMergeContentProvider();	4842	IMergeViewerContentProvider content= getMergeContentProvider();
4848	Object leftContent = content.getLeftContent(oldInput);	4843	Object leftContent = content.getLeftContent(oldInput);
4849	Object rightContent = content.getRightContent(oldInput);
4850		4844
4851	if (leftContent != null && getCompareConfiguration().isLeftEditable() && isLeftDirty()) {	4845	if (leftContent != null && getCompareConfiguration().isLeftEditable() && isLeftDirty()) {
4852	if (fLeftContributor.hasSharedDocument(leftContent)) {	4846	if (fLeftContributor.hasSharedDocument(leftContent)) {
Lines 4855-4867 Link Here
4855	}	4849	}
4856	}	4850	}
4857		4851
		4852	if (!(content instanceof MergeViewerContentProvider) \|\| isLeftDirty()) {
		4853	super.flushLeftSide(oldInput, monitor);
		4854	}
		4855	}
		4856
		4857	void flushRightSide(Object oldInput, IProgressMonitor monitor){
		4858	IMergeViewerContentProvider content= getMergeContentProvider();
		4859	Object rightContent = content.getRightContent(oldInput);
		4860
4858	if (rightContent != null && getCompareConfiguration().isRightEditable() && isRightDirty()) {	4861	if (rightContent != null && getCompareConfiguration().isRightEditable() && isRightDirty()) {
4859	if (fRightContributor.hasSharedDocument(rightContent)) {	4862	if (fRightContributor.hasSharedDocument(rightContent)) {
4860	if (flush(fRightContributor))	4863	if (flush(fRightContributor))
4861	setRightDirty(false);	4864	setRightDirty(false);
4862	}	4865	}
4863	}	4866	}
4864		4867
		4868	if (!(content instanceof MergeViewerContentProvider) \|\| isRightDirty()) {
		4869	super.flushRightSide(oldInput, monitor);
		4870	}
		4871	}
		4872
		4873	/* (non-Javadoc)
		4874	* @see org.eclipse.compare.contentmergeviewer.ContentMergeViewer#flushContent(java.lang.Object, org.eclipse.core.runtime.IProgressMonitor)
		4875	*/
		4876	protected void flushContent(Object oldInput, IProgressMonitor monitor) {
		4877	flushLeftSide(oldInput, monitor);
		4878	flushRightSide(oldInput, monitor);
		4879
		4880	IMergeViewerContentProvider content = getMergeContentProvider();
		4881
4865	if (!(content instanceof MergeViewerContentProvider) \|\| isLeftDirty() \|\| isRightDirty()) {	4882	if (!(content instanceof MergeViewerContentProvider) \|\| isLeftDirty() \|\| isRightDirty()) {
4866	super.flushContent(oldInput, monitor);	4883	super.flushContent(oldInput, monitor);
4867	}	4884	}

Lines 11-19 Link Here

(-)compare/org/eclipse/compare/CompareEditorInput.java (-32 / +132 lines)
11	package org.eclipse.compare;	11	package org.eclipse.compare;
12		12
13	import java.lang.reflect.InvocationTargetException;	13	import java.lang.reflect.InvocationTargetException;
14	import java.util.ArrayList;
15	import java.util.ResourceBundle;	14	import java.util.ResourceBundle;
16		15
		16	import org.eclipse.compare.contentmergeviewer.ContentMergeViewer;
17	import org.eclipse.compare.contentmergeviewer.IFlushable;	17	import org.eclipse.compare.contentmergeviewer.IFlushable;
18	import org.eclipse.compare.internal.BinaryCompareViewer;	18	import org.eclipse.compare.internal.BinaryCompareViewer;
19	import org.eclipse.compare.internal.ChangePropertyAction;	19	import org.eclipse.compare.internal.ChangePropertyAction;
Lines 24-29 Link Here
24	import org.eclipse.compare.internal.CompareStructureViewerSwitchingPane;	24	import org.eclipse.compare.internal.CompareStructureViewerSwitchingPane;
25	import org.eclipse.compare.internal.CompareUIPlugin;	25	import org.eclipse.compare.internal.CompareUIPlugin;
26	import org.eclipse.compare.internal.ICompareUIConstants;	26	import org.eclipse.compare.internal.ICompareUIConstants;
		27	import org.eclipse.compare.internal.IFlushable2;
27	import org.eclipse.compare.internal.OutlineViewerCreator;	28	import org.eclipse.compare.internal.OutlineViewerCreator;
28	import org.eclipse.compare.internal.Utilities;	29	import org.eclipse.compare.internal.Utilities;
29	import org.eclipse.compare.internal.ViewerDescriptor;	30	import org.eclipse.compare.internal.ViewerDescriptor;
Lines 177-183 Link Here
177	* @since 3.3	178	* @since 3.3
178	*/	179	*/
179	public static final String PROP_SELECTED_EDITION= ICompareUIConstants.PROP_SELECTED_EDITION;	180	public static final String PROP_SELECTED_EDITION= ICompareUIConstants.PROP_SELECTED_EDITION;
180		181
181	private static final String COMPARE_EDITOR_IMAGE_NAME= "eview16/compare_view.gif"; //$NON-NLS-1$	182	private static final String COMPARE_EDITOR_IMAGE_NAME= "eview16/compare_view.gif"; //$NON-NLS-1$
182	private static Image fgTitleImage;	183	private static Image fgTitleImage;
183		184
Lines 193-200 Link Here
193	private String fTitle;	194	private String fTitle;
194	private ListenerList fListenerList= new ListenerList();	195	private ListenerList fListenerList= new ListenerList();
195	private CompareNavigator fNavigator;	196	private CompareNavigator fNavigator;
196	private boolean fDirty= false;	197	private ContentMergeViewer fLeftDirtyViewer = null;
197	private ArrayList fDirtyViewers= new ArrayList();	198	private ContentMergeViewer fRightDirtyViewer = null;
198	private IPropertyChangeListener fDirtyStateListener;	199	private IPropertyChangeListener fDirtyStateListener;
199		200
200	boolean fStructureCompareOnSingleClick= true;	201	boolean fStructureCompareOnSingleClick= true;
Lines 1016-1033 Link Here
1016	}	1017	}
1017		1018
1018	/**	1019	/**
1019	* Returns <code>true</code> if there are unsaved changes.	1020	* Returns <code>true</code> if there are unsaved changes in either left or
1020	* The value returned is the value of the <code>DIRTY_STATE</code> property of this input object.	1021	* right side. The value returned is the value of the
1021		1022	* <code>DIRTY_STATE</code> property of this input object.
1022	* Returns <code>true</code> if this input has unsaved changes,	1023	*
1023	* that is if <code>setDirty(true)</code> has been called.	1024	* Returns <code>true</code> if left or right side has unsaved changes
1024	* Subclasses don't have to override if the functionality provided by <code>setDirty</code>	1025	* Subclasses don't have to override if the functionality provided by
1025	* is sufficient.	1026	* <code>setDirty</code> is sufficient.
1026	*	1027	*
1027	* @return <code>true</code> if there are changes that need to be saved	1028	* @return <code>true</code> if there are changes that need to be saved
1028	*/	1029	*/
1029	public boolean isSaveNeeded() {	1030	public boolean isSaveNeeded() {
1030	return fDirty \|\| fDirtyViewers.size() > 0;	1031	return isLeftSaveNeeded() \|\| isRightSaveNeeded();
		1032	}
		1033
		1034	/**
		1035	* Returns <code>true</code> if there are unsaved changes for left side.
		1036	*
		1037	* @return <code>true</code> if there are changes that need to be saved
		1038	* @noreference This method is not intended to be referenced by clients.
		1039	*/
		1040	protected boolean isLeftSaveNeeded() {
		1041	return fLeftDirtyViewer != null;
		1042	}
		1043
		1044	/**
		1045	* Returns <code>true</code> if there are unsaved changes for right side.
		1046	*
		1047	* @return <code>true</code> if there are changes that need to be saved
		1048	* @noreference This method is not intended to be referenced by clients.
		1049	*/
		1050	protected boolean isRightSaveNeeded() {
		1051	return fRightDirtyViewer != null;
1031	}	1052	}
1032		1053
1033	/**	1054	/**
Lines 1044-1074 Link Here
1044	}	1065	}
1045		1066
1046	/**	1067	/**
1047	* Sets the dirty state of this input to the given	1068	* Sets the dirty state of this input to the given value and sends out a
1048	* value and sends out a <code>PropertyChangeEvent</code> if the new value differs from the old value.	1069	* <code>PropertyChangeEvent</code> if the new value differs from the old
1049	*	1070	* value. Direct calling this method with parameter dirty equal to
1050	* @param dirty the dirty state for this compare input	1071	* <code>false</code> when there are unsaved changes in viewers, results in
		1072	* inconsistent state. The dirty state of compare input should be based only
		1073	* on the information if there are changes in viewers for left or right
		1074	* side.
		1075	*
		1076	* @param dirty
		1077	* the dirty state for this compare input
1051	*/	1078	*/
1052	public void setDirty(boolean dirty) {	1079	public void setDirty(boolean dirty) {
1053	boolean oldDirty = fDirty \|\| fDirtyViewers.size() > 0;	1080	boolean oldDirty = isSaveNeeded();
1054	fDirty= dirty;	1081	boolean newDirty = dirty \|\| isSaveNeeded();
1055	if (!fDirty)	1082	if (!newDirty) {
1056	fDirtyViewers.clear();	1083	fLeftDirtyViewer = null;
1057	if (oldDirty != dirty)	1084	fRightDirtyViewer = null;
1058	Utilities.firePropertyChange(fListenerList, this, DIRTY_STATE, Boolean.valueOf(oldDirty), Boolean.valueOf(dirty));	1085	}
		1086	if (oldDirty != isSaveNeeded()) {
		1087	Utilities.firePropertyChange(fListenerList, this, DIRTY_STATE, Boolean.valueOf(oldDirty), Boolean.valueOf(isSaveNeeded()));
		1088	}
1059	}	1089	}
1060		1090
		1091	/**
		1092	* Method adds or removes viewers that changed left or right side of this
		1093	* compare input. Any modification of any of the list of viewers may result
		1094	* in dirty state change.
		1095	*
		1096	* @param source
		1097	* the object that fired <code>PropertyChangeEvent</code>
		1098	* modifying the dirty state
		1099	* @param dirty
		1100	* value that describes if the changes were added or removed
		1101	*/
1061	private void setDirty(Object source, boolean dirty) {	1102	private void setDirty(Object source, boolean dirty) {
1062	Assert.isNotNull(source);	1103	Assert.isNotNull(source);
1063	boolean oldDirty= fDirty \|\| fDirtyViewers.size() > 0;	1104	boolean oldDirty = isSaveNeeded();
1064	if (dirty)	1105	ContentMergeViewer cmv = (ContentMergeViewer) source;
1065	fDirtyViewers.add(source);	1106	if (dirty) {
1066	else	1107	if (cmv.internalIsLeftDirty()) {
1067	fDirtyViewers.remove(source);	1108	if (fLeftDirtyViewer == null) {
1068	boolean newDirty= fDirty \|\| fDirtyViewers.size() > 0;	1109	fLeftDirtyViewer = cmv;
1069	if (DEBUG) System.out.println("setDirty("+source+", "+dirty+"): " + newDirty); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$	1110	}
1070	if (oldDirty != newDirty)	1111	}
		1112	if (cmv.internalIsRightDirty()) {
		1113	if (fRightDirtyViewer == null) {
		1114	fRightDirtyViewer = cmv;
		1115	}
		1116	}
		1117	} else {
		1118	if (!cmv.internalIsLeftDirty()) {
		1119	fLeftDirtyViewer = null;
		1120	}
		1121	if (!cmv.internalIsRightDirty()) {
		1122	fRightDirtyViewer = null;
		1123	}
		1124	}
		1125	boolean newDirty = isSaveNeeded();
		1126	if (DEBUG) {
		1127	System.out.println("setDirty(" + source + ", " + dirty + "): " + newDirty); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
		1128	}
		1129	if (oldDirty != newDirty) {
1071	Utilities.firePropertyChange(fListenerList, this, DIRTY_STATE, Boolean.valueOf(oldDirty), Boolean.valueOf(newDirty));	1130	Utilities.firePropertyChange(fListenerList, this, DIRTY_STATE, Boolean.valueOf(oldDirty), Boolean.valueOf(newDirty));
		1131	}
1072	}	1132	}
1073		1133
1074	/* (non Javadoc)	1134	/* (non Javadoc)
Lines 1129-1135 Link Here
1129	flushViewer(fStructurePane2, monitor);	1189	flushViewer(fStructurePane2, monitor);
1130	flushViewer(fContentInputPane, monitor);	1190	flushViewer(fContentInputPane, monitor);
1131	}	1191	}
1132		1192
		1193	/**
		1194	* @param monitor
		1195	* @noreference This method is not intended to be referenced by clients.
		1196	*/
		1197	protected void flushLeftViewers(IProgressMonitor monitor) {
		1198	// flush changes in left dirty viewer
		1199	flushViewer(fStructureInputPane, monitor);
		1200	flushViewer(fStructurePane1, monitor);
		1201	flushViewer(fStructurePane2, monitor);
		1202	flushLeftViewer(fContentInputPane, monitor);
		1203	}
		1204
		1205	/**
		1206	* @param monitor
		1207	* @noreference This method is not intended to be referenced by clients.
		1208	*/
		1209	protected void flushRightViewers(IProgressMonitor monitor) {
		1210	// flush changes in right dirty viewer
		1211	flushViewer(fStructureInputPane, monitor);
		1212	flushViewer(fStructurePane1, monitor);
		1213	flushViewer(fStructurePane2, monitor);
		1214	flushRightViewer(fContentInputPane, monitor);
		1215	}
		1216
1133	private static void flushViewer(CompareViewerPane pane, IProgressMonitor pm) {	1217	private static void flushViewer(CompareViewerPane pane, IProgressMonitor pm) {
1134	if (pane != null) {	1218	if (pane != null) {
1135	IFlushable flushable = (IFlushable)Utilities.getAdapter(pane, IFlushable.class);	1219	IFlushable flushable = (IFlushable)Utilities.getAdapter(pane, IFlushable.class);
Lines 1138-1143 Link Here
1138	}	1222	}
1139	}	1223	}
1140		1224
		1225	private static void flushLeftViewer(CompareViewerPane pane, IProgressMonitor pm) {
		1226	if (pane != null) {
		1227	IFlushable2 flushable = (IFlushable2)Utilities.getAdapter(pane, IFlushable2.class);
		1228	if (flushable != null)
		1229	flushable.flushLeft(pm);
		1230	}
		1231	}
		1232
		1233	private static void flushRightViewer(CompareViewerPane pane, IProgressMonitor pm) {
		1234	if (pane != null) {
		1235	IFlushable2 flushable = (IFlushable2)Utilities.getAdapter(pane, IFlushable2.class);
		1236	if (flushable != null)
		1237	flushable.flushRight(pm);
		1238	}
		1239	}
		1240
1141	/* (non-Javadoc)	1241	/* (non-Javadoc)
1142	* @see org.eclipse.compare.ICompareContainer#addCompareInputChangeListener(org.eclipse.compare.structuremergeviewer.ICompareInput, org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener)	1242	* @see org.eclipse.compare.ICompareContainer#addCompareInputChangeListener(org.eclipse.compare.structuremergeviewer.ICompareInput, org.eclipse.compare.structuremergeviewer.ICompareInputChangeListener)
1143	*/	1243	*/

Added Link Here

(-)compare/org/eclipse/compare/internal/IFlushable2.java (+28 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.compare.internal;
12
13	import org.eclipse.compare.contentmergeviewer.IFlushable;
14	import org.eclipse.core.runtime.IProgressMonitor;
15
16	/**
17	* Interface which provides the ability to flush the contents from the specified
18	* side of the viewer.
19	*
20	* @see IFlushable
21	*
22	* @since 3.7
23	*/
24	public interface IFlushable2 {
25	void flushLeft(IProgressMonitor monitor);
26
27	void flushRight(IProgressMonitor monitor);
28	}

Lines 1-5 Link Here

(-)src/org/eclipse/team/internal/ui/synchronize/LocalResourceSaveableComparison.java (-7 / +28 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2006, 2007 IBM Corporation and others.	2	* Copyright (c) 2006, 2010 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 11-16 Link Here
11	package org.eclipse.team.internal.ui.synchronize;	11	package org.eclipse.team.internal.ui.synchronize;
12		12
13	import org.eclipse.compare.*;	13	import org.eclipse.compare.*;
		14	import org.eclipse.compare.internal.ISavingSaveable;
14	import org.eclipse.compare.structuremergeviewer.ICompareInput;	15	import org.eclipse.compare.structuremergeviewer.ICompareInput;
15	import org.eclipse.core.resources.IFile;	16	import org.eclipse.core.resources.IFile;
16	import org.eclipse.core.runtime.*;	17	import org.eclipse.core.runtime.*;
Lines 35-41 Link Here
35	* @see LocalResourceTypedElement	36	* @see LocalResourceTypedElement
36	* @since 3.3	37	* @since 3.3
37	*/	38	*/
38	public abstract class LocalResourceSaveableComparison extends SaveableComparison implements IPropertyChangeListener {	39	public abstract class LocalResourceSaveableComparison extends SaveableComparison implements IPropertyChangeListener, ISavingSaveable {
39		40
40	private final ICompareInput input;	41	private final ICompareInput input;
41	private final CompareEditorInput editorInput;	42	private final CompareEditorInput editorInput;
Lines 130-139 Link Here
130	flushViewers(Policy.subMonitorFor(monitor, 40));	131	flushViewers(Policy.subMonitorFor(monitor, 40));
131	// Then we tell the input to commit its changes	132	// Then we tell the input to commit its changes
132	// Only the left is ever saveable	133	// Only the left is ever saveable
133	ITypedElement left = getFileElement();	134	ITypedElement te = getFileElement();
134	if (left instanceof LocalResourceTypedElement) {	135	if (te instanceof LocalResourceTypedElement) {
135	LocalResourceTypedElement te = (LocalResourceTypedElement) left;	136	LocalResourceTypedElement lrte = (LocalResourceTypedElement) te;
136	te.commit(Policy.subMonitorFor(monitor, 60));	137	lrte.commit(Policy.subMonitorFor(monitor, 60));
137	}	138	}
138	} finally {	139	} finally {
139	// Make sure we fire a change for the compare input to update the viewers	140	// Make sure we fire a change for the compare input to update the viewers
Lines 150-156 Link Here
150	* @throws CoreException	151	* @throws CoreException
151	*/	152	*/
152	protected void flushViewers(IProgressMonitor monitor) throws CoreException {	153	protected void flushViewers(IProgressMonitor monitor) throws CoreException {
153	editorInput.saveChanges(monitor);	154	if (editorInput instanceof SaveablesCompareEditorInput) {
		155	((SaveablesCompareEditorInput) editorInput).saveChanges(monitor, this);
		156	} else {
		157	editorInput.saveChanges(monitor);
		158	}
154	}	159	}
155		160
156	/**	161	/**
Lines 206-211 Link Here
206	public boolean isDirty() {	211	public boolean isDirty() {
207	// We need to get the dirty state from the compare editor input	212	// We need to get the dirty state from the compare editor input
208	// since it is our only connection to the merge viewer	213	// since it is our only connection to the merge viewer
		214	if (editorInput instanceof SaveablesCompareEditorInput) {
		215	return ((SaveablesCompareEditorInput) editorInput).isSaveNeeded(this);
		216	}
209	return editorInput.isSaveNeeded();	217	return editorInput.isSaveNeeded();
210	}	218	}
211		219
Lines 232-237 Link Here
232	* @see org.eclipse.ui.Saveable#getName()	240	* @see org.eclipse.ui.Saveable#getName()
233	*/	241	*/
234	public String getName() {	242	public String getName() {
		243	// Return the name of the file element as held in the compare input
		244	if (fileElement.equals(input.getLeft())) {
		245	return input.getLeft().getName();
		246	}
		247	if (fileElement.equals(input.getRight())) {
		248	return input.getRight().getName();
		249	}
		250	// Fallback call returning name of the main non-null element of the input
		251	// see org.eclipse.team.internal.ui.mapping.AbstractCompareInput#getMainElement()
235	return input.getName();	252	return input.getName();
236	}	253	}
237		254
Lines 345-348 Link Here
345	}	362	}
346	return false;	363	return false;
347	}	364	}
		365
		366	public boolean isSaving() {
		367	return isSaving;
		368	}
348	}	369	}

Lines 126-135 Link Here

(-)src/org/eclipse/team/internal/ui/synchronize/SaveablesCompareEditorInput.java (-4 / +42 lines)
126	closed = closeEditor(true);	126	closed = closeEditor(true);
127	}	127	}
128	if (!closed) {	128	if (!closed) {
129	// The editor was closed either because the compare	129	// The editor was not closed either because the compare
130	// input still has changes	130	// input still has changes or because the editor input
131	// or because the editor input is dirty. In either case,	131	// is dirty. In either case, fire the changes
132	// fire the changes
133	// to the registered listeners	132	// to the registered listeners
134	propogateInputChange();	133	propogateInputChange();
135	}	134	}
Lines 360-365 Link Here
360	}	359	}
361		360
362	/**	361	/**
		362	* Returns <code>true</code> if the given saveable contains any unsaved
		363	* changes. If the saveable doesn't match either left nor right side of the
		364	* current editor input {@link CompareEditorInput#isSaveNeeded()} is called.
		365	* <p>
		366	* This method is preferred to {@link CompareEditorInput#isSaveNeeded()}.
		367	*
		368	* @param the
		369	* the saveable to check
		370	* @return <code>true</code> if there are changes that need to be saved
		371	* @since 3.7
		372	*/
		373	boolean isSaveNeeded(Saveable saveable) {
		374	if (saveable == null) {
		375	return isSaveNeeded();
		376	}
		377	if (saveable.equals(fLeftSaveable)) {
		378	return isLeftSaveNeeded();
		379	}
		380	if (saveable.equals(fRightSaveable)) {
		381	return isRightSaveNeeded();
		382	}
		383	// Fallback call returning true if there are unsaved changes in either
		384	// left or right side
		385	return isSaveNeeded();
		386	}
		387
		388	void saveChanges(IProgressMonitor monitor, Saveable saveable)
		389	throws CoreException {
		390	if (saveable.equals(fLeftSaveable)) {
		391	flushLeftViewers(monitor);
		392	return;
		393	} else if (saveable.equals(fRightSaveable)) {
		394	flushRightViewers(monitor);
		395	return;
		396	}
		397	Assert.isTrue(false, "invalid saveable parameter"); //$NON-NLS-1$
		398	}
		399
		400	/**
363	* Close the editor if it is not dirty. If it is still dirty, let the	401	* Close the editor if it is not dirty. If it is still dirty, let the
364	* content merge viewer handle the compare input change.	402	* content merge viewer handle the compare input change.
365	*	403	*