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
|
/*******************************************************************************
* 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.synchronize.actions;
import org.eclipse.compare.CompareUI;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.team.core.synchronize.SyncInfo;
import org.eclipse.team.internal.ui.Utils;
import org.eclipse.team.internal.ui.synchronize.SyncInfoModelElement;
import org.eclipse.team.ui.synchronize.ISynchronizePageSite;
import org.eclipse.team.ui.synchronize.SyncInfoCompareInput;
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;
import org.eclipse.ui.IWorkbenchSite;
/**
* Action to open a compare editor from a SyncInfo object.
*
* @see SyncInfoCompareInput
* @since 3.0
*/
public class OpenInCompareAction extends Action {
private String name;
private ISynchronizePageSite site;
public OpenInCompareAction(ISynchronizePageSite site, String name) {
this.name = name;
this.site = site;
Utils.initAction(this, "action.openInCompareEditor."); //$NON-NLS-1$
}
public void run() {
ISelection selection = site.getSelectionProvider().getSelection();
if(selection instanceof IStructuredSelection) {
Object obj = ((IStructuredSelection) selection).getFirstElement();
if (obj instanceof SyncInfoModelElement) {
SyncInfo info = ((SyncInfoModelElement) obj).getSyncInfo();
if (info != null) {
openCompareEditor(site, name, info, true);
}
}
}
}
public static SyncInfoCompareInput openCompareEditor(ISynchronizePageSite site, String name, SyncInfo info, boolean keepFocus) {
SyncInfoCompareInput input = getCompareInput(name, info);
if(input != null) {
IWorkbenchSite ws = site.getWorkbenchSite();
if (ws == null) return null;
IWorkbenchPage wpage = ws.getPage();
IEditorPart editor = findReusableCompareEditor(wpage);
if(editor != null) {
IEditorInput otherInput = editor.getEditorInput();
if(otherInput instanceof SyncInfoCompareInput && otherInput.equals(input)) {
// simply provide focus to editor
wpage.activate(editor);
} else {
// if editor is currently not open on that input either re-use existing
if(editor != null && editor instanceof IReusableEditor) {
CompareUI.reuseCompareEditor(input, (IReusableEditor)editor);
wpage.activate(editor);
}
}
} else {
CompareUI.openCompareEditor(input);
editor = wpage.getActiveEditor();
}
if(keepFocus) {
site.setFocus();
}
return input;
}
return null;
}
/**
* Returns a SyncInfoCompareInput instance for the current selection.
*/
private static SyncInfoCompareInput getCompareInput(String name, SyncInfo info) {
if (info != null && info.getLocal() instanceof IFile) {
return new SyncInfoCompareInput(name, 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;
}
}
|
