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
197
198
199
200
201
202
203
204
205
206
207
208
209
|
/*******************************************************************************
* Copyright (c) 2000, 2004 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.ccvs.ui;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.runtime.*;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.team.core.RepositoryProvider;
import org.eclipse.team.core.TeamException;
import org.eclipse.team.internal.ccvs.core.*;
import org.eclipse.team.internal.ccvs.core.resources.CVSWorkspaceRoot;
import org.eclipse.team.internal.ccvs.ui.actions.EditorsAction;
/**
* IFileModificationValidator that is pluged into the CVS Repository Provider
*/
public class FileModificationValidator implements ICVSFileModificationValidator {
public static final IStatus OK = new Status(IStatus.OK, CVSUIPlugin.ID, 0, Policy.bind("ok"), null); //$NON-NLS-1$
public FileModificationValidator() {
}
/**
* @see org.eclipse.core.resources.IFileModificationValidator#validateEdit(org.eclipse.core.resources.IFile, java.lang.Object)
*/
public IStatus validateEdit(IFile[] files, Object context) {
IFile[] readOnlyFiles = getManagedReadOnlyFiles(files);
if (readOnlyFiles.length == 0) return OK;
return edit(readOnlyFiles, getShell(context));
}
/**
* @see org.eclipse.core.resources.IFileModificationValidator#validateSave(org.eclipse.core.resources.IFile)
*/
public IStatus validateSave(IFile file) {
if (!needsCheckout(file)) return OK;
return edit(new IFile[] {file}, (Shell)null);
}
/**
* @see org.eclipse.team.internal.ccvs.core.ICVSFileModificationValidator#validateMoveDelete(org.eclipse.core.resources.IFile[], org.eclipse.core.runtime.IProgressMonitor)
*/
public IStatus validateMoveDelete(IFile[] files, IProgressMonitor monitor) {
IFile[] readOnlyFiles = getManagedReadOnlyFiles(files);
if (readOnlyFiles.length == 0) return OK;
try {
edit(readOnlyFiles, monitor);
return OK;
} catch (CVSException e) {
return e.getStatus();
}
}
private IFile[] getManagedReadOnlyFiles(IFile[] files) {
List readOnlys = new ArrayList();
for (int i = 0; i < files.length; i++) {
IFile iFile = files[i];
if (needsCheckout(iFile)) {
readOnlys.add(iFile);
}
}
return (IFile[]) readOnlys.toArray(new IFile[readOnlys.size()]);
}
private boolean needsCheckout(IFile file) {
try {
if (file.isReadOnly()) {
ICVSFile cvsFile = CVSWorkspaceRoot.getCVSFileFor(file);
return cvsFile.isManaged();
}
} catch (CVSException e) {
// Log the exception and assume we don't need a checkout
CVSUIPlugin.log(e);
}
return false;
}
private CVSTeamProvider getProvider(IFile[] files) {
CVSTeamProvider provider = (CVSTeamProvider)RepositoryProvider.getProvider(files[0].getProject(), CVSProviderPlugin.getTypeId());
return provider;
}
private Shell getShell(Object context) {
if (context instanceof Shell)
return (Shell)context;
return null;
}
private IStatus getStatus(InvocationTargetException e) {
Throwable target = e.getTargetException();
if (target instanceof TeamException) {
return ((TeamException) target).getStatus();
} else if (target instanceof CoreException) {
return ((CoreException) target).getStatus();
}
return new Status(IStatus.ERROR, CVSUIPlugin.ID, 0, Policy.bind("internal"), target); //$NON-NLS-1$
}
private IStatus edit(final IFile[] files, final Shell shell) {
if (isPerformEdit()) {
try {
if (shell != null && !promptToEditFiles(files, shell)) {
// The user didn't want to edit.
// OK is returned but the file remains read-only
throw new InterruptedException();
}
// Run the edit in a runnable in order to get a busy cursor.
// This runnable is syncExeced in order to get a busy cursor
CVSUIPlugin.runWithProgress(shell, false, new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
try {
edit(files, monitor);
} catch (CVSException e) {
new InvocationTargetException(e);
}
}
}, CVSUIPlugin.PERFORM_SYNC_EXEC);
} catch (InvocationTargetException e) {
return getStatus(e);
} catch (InterruptedException e) {
// Must return an error to indicate that it is not OK to edit the files
return new Status(IStatus.CANCEL, CVSUIPlugin.ID, 0, Policy.bind("FileModificationValidator.vetoMessage"), null); //$NON-NLS-1$;
}
} else {
// Allow the files to be edited without notifying the server
for (int i = 0; i < files.length; i++) {
IFile file = files[i];
file.setReadOnly(false);
}
}
return OK;
}
private boolean promptToEditFiles(IFile[] files, Shell shell) throws InvocationTargetException, InterruptedException {
if (files.length == 0)
return true;
if(isNeverPrompt())
return true;
// Contact the server to see if anyone else is editing the files
EditorsAction editors = fetchEditors(files, shell);
if (editors.isEmpty()) {
if (isAlwaysPrompt())
return (promptEdit(shell));
return true;
} else {
return (editors.promptToEdit(shell));
}
}
private boolean promptEdit(Shell shell) {
// Open the dialog using a sync exec (there are no guarentees that we
// were called from the UI thread
final boolean[] result = new boolean[] { false };
CVSUIPlugin.openDialog(shell, new CVSUIPlugin.IOpenableInShell() {
public void open(Shell shell) {
result[0] = MessageDialog.openQuestion(shell,Policy.bind("FileModificationValidator.3"),Policy.bind("FileModificationValidator.4")); //$NON-NLS-1$ //$NON-NLS-2$
}
}, CVSUIPlugin.PERFORM_SYNC_EXEC);
return result[0];
}
private boolean isPerformEdit() {
return ICVSUIConstants.PREF_EDIT_PROMPT_EDIT.equals(CVSUIPlugin.getPlugin().getPreferenceStore().getString(ICVSUIConstants.PREF_EDIT_ACTION));
}
private EditorsAction fetchEditors(IFile[] files, Shell shell) throws InvocationTargetException, InterruptedException {
final EditorsAction editors = new EditorsAction(getProvider(files), files);
// Fetch the editors in a runnable in order to get the busy cursor
CVSUIPlugin.runWithProgress(shell, false, new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException, InterruptedException {
editors.run(monitor);
}
}, CVSUIPlugin.PERFORM_SYNC_EXEC);
return editors;
}
private boolean isNeverPrompt() {
return ICVSUIConstants.PREF_EDIT_PROMPT_NEVER.equals(CVSUIPlugin.getPlugin().getPreferenceStore().getString(ICVSUIConstants.PREF_EDIT_PROMPT));
}
private boolean isAlwaysPrompt() {
return ICVSUIConstants.PREF_EDIT_PROMPT_ALWAYS.equals(CVSUIPlugin.getPlugin().getPreferenceStore().getString(ICVSUIConstants.PREF_EDIT_PROMPT));
}
private void edit(IFile[] files, IProgressMonitor monitor) throws CVSException {
getProvider(files).edit(files, false /* recurse */, true /* notify server */, ICVSFile.NO_NOTIFICATION, monitor);
}
}
|
