framework/bundles/org.eclipse.team.ecf.ui/src/org/eclipse/team/internal/ecf/ui/handlers/SynchronizeWithHandler.java

/******************************************************************************
 * Copyright (c) 2008 Versant 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:
 *     Remy Chi Jian Suen (Versant Corporation) - initial API and implementation
 ******************************************************************************/
package org.eclipse.team.internal.ecf.ui.handlers;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.*;
import org.eclipse.ecf.core.IContainer;
import org.eclipse.ecf.core.identity.ID;
import org.eclipse.ecf.core.user.IUser;
import org.eclipse.ecf.core.util.ECFException;
import org.eclipse.ecf.presence.roster.IRoster;
import org.eclipse.ecf.presence.roster.IRosterEntry;
import org.eclipse.ecf.presence.ui.menu.AbstractRosterMenuHandler;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.team.internal.ecf.core.RemoteShare;
import org.eclipse.team.internal.ecf.core.TeamSynchronization;
import org.eclipse.team.internal.ecf.ui.Messages;
import org.eclipse.team.internal.ecf.ui.subscriber.RemoteSubscriberParticipant;
import org.eclipse.team.internal.ecf.ui.wizards.RemotePeerSynchronizeWizard;
import org.eclipse.team.ui.TeamUI;
import org.eclipse.team.ui.synchronize.ISynchronizeParticipant;
import org.eclipse.ui.*;
import org.eclipse.ui.handlers.HandlerUtil;

class SynchronizeWithHandler extends AbstractRosterMenuHandler {

	SynchronizeWithHandler(IRosterEntry entry) {
		super(entry);
	}

	public Object execute(ExecutionEvent event) throws ExecutionException {
		IRosterEntry selectedEntry = getRosterEntry();
		IRoster roster = selectedEntry.getRoster();
		final IUser remoteUser = roster.getUser();
		final ID localId = remoteUser.getID();
		final ID remoteId = selectedEntry.getUser().getID();
		IContainer container = (IContainer) roster.getPresenceContainerAdapter().getAdapter(IContainer.class);

		final IResource[] resources = getResources(event);
		final RemoteShare share = TeamSynchronization.getShare(container.getID());

		IWorkbenchPart part = HandlerUtil.getActivePart(event);
		final IWorkbenchPartSite site = part == null ? null : part.getSite();

		final Shell shell = HandlerUtil.getActiveShellChecked(event);
		ProgressMonitorDialog dialog = new ProgressMonitorDialog(shell);

		final boolean[] response = {true};

		IRunnableWithProgress runnable = new IRunnableWithProgress() {
			public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
				if (resources.length == 1) {
					monitor.beginTask(NLS.bind(Messages.SynchronizeWithHandler_SynchronizeResourceTaskName, resources[0].getName()), IProgressMonitor.UNKNOWN);
				} else {
					monitor.beginTask(Messages.SynchronizeWithHandler_SynchronizeResourcesTaskName, IProgressMonitor.UNKNOWN);
				}

				try {
					if (share.sendShareRequest(localId, remoteId, resources, monitor)) {
						scheduleRefreshJob(share, localId, remoteId, resources, remoteUser, site);
					} else {
						response[0] = false;
					}
				} catch (ECFException e) {
					throw new InvocationTargetException(e);
				} catch (OperationCanceledException e) {
					// we should only have thrown this if the user canceled the
					// operation, but check for this just in case
					if (!monitor.isCanceled()) {
						throw e;
					}
				}
			}
		};

		try {
			dialog.run(true, true, runnable);

			if (!response[0]) {
				MessageDialog.openInformation(shell, null, Messages.SynchronizeWithHandler_SynchronizeRequestDenial);
			}
		} catch (InvocationTargetException e) {
			Throwable cause = e.getCause();
			if (cause instanceof ECFException) {
				MessageDialog.openError(shell, null, Messages.SynchronizeWithHandler_SynchronizeRequestError);
			}
			TeamSynchronization.log("Failed to contact remote peer", cause); //$NON-NLS-1$
		} catch (InterruptedException e) {
			Thread.interrupted();
			MessageDialog.openError(shell, null, Messages.SynchronizeWithHandler_SynchronizeRequestInterrupted);
			TeamSynchronization.log("Synchronization request operation was interrupted", e); //$NON-NLS-1$
		}

		return null;
	}

	void scheduleRefreshJob(RemoteShare share, ID localId, ID remoteId, IResource[] resources, IUser remoteUser, IWorkbenchPartSite site) {
		RemoteSubscriberParticipant participant = RemotePeerSynchronizeWizard.getSubscriberParticipant(share, localId, remoteId);
		participant.setResources(resources);

		TeamUI.getSynchronizeManager().addSynchronizeParticipants(new ISynchronizeParticipant[] {participant});

		if (resources.length == 1) {
			participant.refresh(resources, NLS.bind(Messages.SynchronizeWithHandler_RemoteSynchronizationTaskName, remoteUser.getNickname()), NLS.bind(Messages.SynchronizeWithHandler_RemoteSynchronizationResourceDescription, resources[0].getName(), remoteUser.getNickname()), site);
		} else {
			participant.refresh(resources, NLS.bind(Messages.SynchronizeWithHandler_RemoteSynchronizationTaskName, remoteUser.getNickname()), NLS.bind(Messages.SynchronizeWithHandler_RemoteSynchronizationResourcesDescription, remoteUser.getNickname()), site);
		}
	}

	public IResource[] getResources(ExecutionEvent event) throws ExecutionException {
		ISelection selection = HandlerUtil.getCurrentSelectionChecked(event);
		if (selection instanceof IStructuredSelection) {
			List workspaceSelection = new ArrayList(((IStructuredSelection) selection).toList());
			for (int i = 0; i < workspaceSelection.size(); i++) {
				IResource resourceOne = (IResource) ((IAdaptable) workspaceSelection.get(i)).getAdapter(IResource.class);
				IPath pathOne = resourceOne.getFullPath();
				for (int j = i + 1; j < workspaceSelection.size(); j++) {
					IResource resourceTwo = (IResource) ((IAdaptable) workspaceSelection.get(j)).getAdapter(IResource.class);
					IPath pathTwo = resourceTwo.getFullPath();

					if (pathOne.isPrefixOf(pathTwo)) {
						workspaceSelection.remove(j);
						i--;
						break;
					} else if (pathTwo.isPrefixOf(pathOne)) {
						workspaceSelection.remove(i);
						i--;
						break;
					}
				}
			}

			IResource[] resources = new IResource[workspaceSelection.size()];
			for (int i = 0; i < resources.length; i++) {
				resources[i] = (IResource) ((IAdaptable) workspaceSelection.get(i)).getAdapter(IResource.class);
			}
			return resources;
		}
		IEditorPart editor = HandlerUtil.getActiveEditorChecked(event);
		IFile file = (IFile) editor.getEditorInput().getAdapter(IFile.class);
		return file == null ? new IResource[0] : new IResource[] {file};
	}

}