1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
|
/*******************************************************************************
* Copyright (c) 2000, 2003 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.team.internal.ui.sync.actions;
import java.lang.reflect.InvocationTargetException;
import org.eclipse.compare.CompareUI;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.core.subscribers.SyncInfo;
import org.eclipse.team.core.sync.IRemoteResource;
import org.eclipse.team.internal.ui.Policy;
import org.eclipse.team.internal.ui.Utils;
import org.eclipse.team.internal.ui.actions.TeamAction;
import org.eclipse.team.internal.ui.sync.compare.SyncInfoCompareInput;
import org.eclipse.team.internal.ui.sync.views.SynchronizeView;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IReusableEditor;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchPartSite;
/**
* Action to open a compare editor from a SyncInfo object.
*
* @see SyncInfoCompareInput
* @since 3.0
*/
public class OpenInCompareAction extends Action {
private SynchronizeView viewer;
public OpenInCompareAction(SynchronizeView viewer) {
this.viewer = viewer;
Utils.initAction(this, "action.openInCompareEditor."); //$NON-NLS-1$
}
public void run() {
ISelection selection = viewer.getViewer().getSelection();
Object obj = ((IStructuredSelection)selection).getFirstElement();
SyncInfo info = getSyncInfo(obj);
openCompareEditor(viewer, info, true /* keep focus */);
}
public static SyncInfoCompareInput openCompareEditor(SynchronizeView viewer, SyncInfo info, boolean keepFocus) {
SyncInfoCompareInput input = getCompareInput(info);
if(input != null) {
IWorkbenchPage page = viewer.getSite().getPage();
IEditorPart editor = findReusableCompareEditor(page);
if(editor != null) {
IEditorInput otherInput = editor.getEditorInput();
if(otherInput instanceof SyncInfoCompareInput && otherInput.equals(input)) {
// simply provide focus to editor
page.activate(editor);
} else {
// if editor is currently not open on that input either re-use existing
if (!prefetchFileContents(viewer, info)) return null;
if(editor != null && editor instanceof IReusableEditor) {
page.activate(editor);
CompareUI.reuseCompareEditor(input, (IReusableEditor)editor);
}
}
} else {
CompareUI.openCompareEditor(input);
}
if(keepFocus) {
SynchronizeView.showInActivePage(viewer.getSite().getPage());
}
return input;
}
return null;
}
/**
* Prefetching the file contents will cache them for use by the compare editor
* so that the compare editor doesn't have to perform file transfers. This will
* make the transfer cancellable.
*/
private static boolean prefetchFileContents(SynchronizeView viewer, SyncInfo info) {
final IRemoteResource remote = info.getRemote();
final IRemoteResource base = info.getBase();
if (remote != null || base != null) {
final boolean[] ok = new boolean[] { true };
viewer.run(new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
try {
monitor.beginTask(null, (remote == null ? 0 : 100) + (base == null ? 0 : 100));
if (remote != null)
remote.getContents(Policy.subMonitorFor(monitor, 100));
if (base != null)
base.getContents(Policy.subMonitorFor(monitor, 100));
monitor.done();
} catch (TeamException e) {
ok[0] = false;
// The sync viewer will show the error to the user so we need only abort the action
throw new InvocationTargetException(e);
}
}
});
return ok[0];
}
return true;
}
/**
* Returns a SyncInfoCompareInput instance for the current selection.
*/
private static SyncInfoCompareInput getCompareInput(SyncInfo info) {
if (info != null && info.getLocal() instanceof IFile) {
return new SyncInfoCompareInput(info);
}
return null;
}
/**
* Returns an editor that can be re-used. An open compare editor that
* has un-saved changes cannot be re-used.
*/
public static IEditorPart findReusableCompareEditor(IWorkbenchPage page) {
IEditorReference[] editorRefs = page.getEditorReferences();
for (int i = 0; i < editorRefs.length; i++) {
IEditorPart part = editorRefs[i].getEditor(true);
if(part != null && part.getEditorInput() instanceof SyncInfoCompareInput) {
if(! part.isDirty()) {
return part;
}
}
}
return null;
}
/**
* Close a compare editor that is opened on the given IResource.
*
* @param site the view site in which to close the editors
* @param resource the resource to use to find the compare editor
*/
public static void closeCompareEditorFor(final IWorkbenchPartSite site, final IResource resource) {
site.getShell().getDisplay().asyncExec(new Runnable() {
public void run() {
IEditorPart editor = findOpenCompareEditor(site, resource);
if(editor != null) {
site.getPage().closeEditor(editor, true /*save changes if required */);
}
}
});
}
/**
* Returns an editor handle if a SyncInfoCompareInput compare editor is opened on
* the given IResource.
*
* @param site the view site in which to search for editors
* @param resource the resource to use to find the compare editor
* @return an editor handle if found and <code>null</code> otherwise
*/
public static IEditorPart findOpenCompareEditor(IWorkbenchPartSite site, IResource resource) {
IWorkbenchPage page = site.getPage();
IEditorReference[] editorRefs = page.getEditorReferences();
for (int i = 0; i < editorRefs.length; i++) {
final IEditorPart part = editorRefs[i].getEditor(false /* don't restore editor */);
if(part != null) {
IEditorInput input = part.getEditorInput();
if(part != null && input instanceof SyncInfoCompareInput) {
SyncInfo inputInfo = ((SyncInfoCompareInput)input).getSyncInfo();
if(inputInfo.getLocal().equals(resource)) {
return part;
}
}
}
}
return null;
}
public static SyncInfo getSyncInfo(Object obj) {
return (SyncInfo)TeamAction.getAdapter(obj, SyncInfo.class);
}
}
|
