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
|
package org.eclipse.team.internal.ccvs.ui.sync;
/*
* (c) Copyright IBM Corp. 2000, 2001.
* All Rights Reserved.
*/
import java.lang.reflect.InvocationTargetException;
import org.eclipse.compare.structuremergeviewer.IDiffContainer;
import org.eclipse.compare.structuremergeviewer.IDiffElement;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.dialogs.ErrorDialog;
import org.eclipse.jface.dialogs.ProgressMonitorDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.team.internal.ccvs.ui.CVSUIPlugin;
import org.eclipse.team.internal.ccvs.ui.Policy;
import org.eclipse.team.ui.sync.ChangedTeamContainer;
import org.eclipse.team.ui.sync.ITeamNode;
import org.eclipse.team.ui.sync.SyncSet;
import org.eclipse.team.ui.sync.UnchangedTeamContainer;
import org.eclipse.ui.actions.WorkspaceModifyOperation;
/**
* Applies merge related actions to the selected ITeamNodes.
*/
abstract class MergeAction extends Action {
public static final int CHECKIN = 0;
public static final int GET = 1;
public static final int DELETE_REMOTE = 2;
public static final int DELETE_LOCAL = 3;
private CVSSyncCompareInput diffModel;
private ISelectionProvider selectionProvider;
// direction can be INCOMING or OUTGOING
private int direction;
private Shell shell;
/**
* Creates a MergeAction which works on selection and doesn't commit changes.
*/
public MergeAction(CVSSyncCompareInput model, ISelectionProvider sp, int direction, String label, Shell shell) {
super(label);
this.diffModel = model;
this.selectionProvider = sp;
this.direction = direction;
this.shell = shell;
}
protected Shell getShell() {
return shell;
}
/**
* Returns true if at least one node can perform the specified action.
*/
private boolean isEnabled(Object[] nodes) {
for (int i = 0; i < nodes.length; i++) {
if (nodes[i] instanceof ITeamNode) {
ITeamNode node = (ITeamNode)nodes[i];
if (isEnabled(node)) {
return true;
}
} else {
if (nodes[i] instanceof IDiffContainer)
if (isEnabled(((IDiffContainer)nodes[i]).getChildren()))
return true;
}
}
return false;
}
protected abstract boolean isEnabled(ITeamNode node);
/**
* Perform the sychronization operation.
*/
public void run() {
ISelection s = selectionProvider.getSelection();
if (!(s instanceof IStructuredSelection) || s.isEmpty()) {
return;
}
final SyncSet set = new SyncSet((IStructuredSelection)s, direction);
set.removeNonApplicableNodes();
final SyncSet[] result = new SyncSet[1];
WorkspaceModifyOperation op = new WorkspaceModifyOperation() {
public void execute(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
result[0] = run(set, monitor);
}
};
try {
run(op, Policy.bind("MergeAction.problemsDuringSync"));
} catch (InterruptedException e) {
}
if (result[0] != null) {
removeNodes(result[0].getChangedNodes());
diffModel.updateView();
}
}
/**
* The given nodes have been synchronized. Remove them from
* the sync set.
*/
private void removeNodes(final ITeamNode[] nodes) {
// Update the model
for (int i = 0; i < nodes.length; i++) {
if (nodes[i].getClass() == UnchangedTeamContainer.class) {
// Unchanged containers get removed automatically when all
// children are removed
continue;
}
if (nodes[i].getClass() == ChangedTeamContainer.class) {
// If this node still has children, convert to an
// unchanged container, then it will disappear when
// all children have been removed.
ChangedTeamContainer container = (ChangedTeamContainer)nodes[i];
IDiffElement[] children = container.getChildren();
if (children.length > 0) {
IDiffContainer parent = container.getParent();
UnchangedTeamContainer unchanged = new UnchangedTeamContainer(parent, container.getResource());
for (int j = 0; j < children.length; j++) {
unchanged.add(children[j]);
}
parent.removeToRoot(container);
continue;
}
// No children, it will get removed below.
}
nodes[i].getParent().removeToRoot(nodes[i]);
}
}
/**
* Updates the action with the latest selection, setting enablement
* as necessary.
*/
public void update() {
IStructuredSelection selection = (IStructuredSelection)selectionProvider.getSelection();
setEnabled(isEnabled(selection.toArray()));
}
/**
* Subclasses must implement this method, which performs action-specific code.
*
* It may return the sync set which was passed in, or null.
*/
protected abstract SyncSet run(SyncSet syncSet, IProgressMonitor monitor);
/**
* Helper method to run a runnable in a progress monitor dialog, and display any errors.
*/
protected void run(IRunnableWithProgress op, String problemMessage) throws InterruptedException {
ProgressMonitorDialog dialog = new ProgressMonitorDialog(getShell());
try {
dialog.run(true, true, op);
} catch (InvocationTargetException e) {
Throwable throwable = e.getTargetException();
IStatus error = null;
if (throwable instanceof CoreException) {
error = ((CoreException)throwable).getStatus();
} else {
error = new Status(IStatus.ERROR, CVSUIPlugin.ID, 1, Policy.bind("simpleInternal") , throwable);
}
ErrorDialog.openError(shell, problemMessage, error.getMessage(), error);
CVSUIPlugin.log(error);
}
}
}
|
