blob: c8e7ebc9f7eb1b8e518abc1211d6ed79a44c51ec (
plain) (
blame)
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
|
/*******************************************************************************
* Copyright (c) 2006 IBM Corporation and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
* which accompanies this distribution, and is available at
* https://www.eclipse.org/legal/epl-2.0/
*
* SPDX-License-Identifier: EPL-2.0
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.team.ui.mapping;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.ui.IPropertyListener;
import org.eclipse.ui.IWorkbenchPartConstants;
import org.eclipse.ui.Saveable;
/**
* A saveable comparison is used to buffer changes made when comparing
* or merging model elements. A buffer can be shared between multiple
* typed elements within a comparison. The saveable is used by the comparison
* container in order to determine when a save is required.
* <p>
* Clients may subclass this class.
*
* @since 3.2
*/
public abstract class SaveableComparison extends Saveable {
/**
* The property id for <code>isDirty</code>.
*/
public static final int PROP_DIRTY = IWorkbenchPartConstants.PROP_DIRTY;
private boolean dirty;
private ListenerList<IPropertyListener> listeners = new ListenerList<>(ListenerList.IDENTITY);
/**
* {@inheritDoc}
*/
@Override
public boolean isDirty() {
return dirty;
}
/**
* {@inheritDoc}
*/
@Override
public void doSave(IProgressMonitor monitor) throws CoreException {
if (!isDirty())
return;
performSave(monitor);
setDirty(false);
}
/**
* Revert any changes in the buffer back to the last saved state.
* @param monitor a progress monitor on <code>null</code>
* if progress feedback is not required
*/
public void doRevert(IProgressMonitor monitor) {
if (!isDirty())
return;
performRevert(monitor);
setDirty(false);
}
/**
* Add a property change listener. Adding a listener
* that is already registered has no effect.
* @param listener the listener
*/
public void addPropertyListener(IPropertyListener listener) {
listeners.add(listener);
}
/**
* Remove a property change listener. Removing a listener
* that is not registered has no effect.
* @param listener the listener
*/
public void removePropertyListener(IPropertyListener listener) {
listeners.remove(listener);
}
/**
* Set the dirty state of this buffer. If the state
* has changed, a property change event will be fired.
* @param dirty the dirty state
*/
protected void setDirty(boolean dirty) {
if (this.dirty == dirty) {
return;
}
this.dirty = dirty;
firePropertyChange(PROP_DIRTY);
}
/**
* Fire a property change event for this buffer.
* @param property the property that changed
*/
protected void firePropertyChange(final int property) {
Object[] allListeners = listeners.getListeners();
for (int i = 0; i < allListeners.length; i++) {
final Object object = allListeners[i];
SafeRunner.run(new ISafeRunnable() {
@Override
public void run() throws Exception {
((IPropertyListener)object).propertyChanged(SaveableComparison.this, property);
}
@Override
public void handleException(Throwable exception) {
// handled by platform
}
});
}
}
/**
* Method invoked from {@link #doSave(IProgressMonitor)} to write
* out the buffer. By default, this method invokes <code>doSave</code>
* on the buffers saveable model.
* @param monitor a progress monitor
* @throws CoreException if errors occur
*/
protected abstract void performSave(IProgressMonitor monitor) throws CoreException;
/**
* Method invoked from {@link #doRevert(IProgressMonitor)} to discard the
* changes in the buffer.
* @param monitor a progress monitor
*/
protected abstract void performRevert(IProgressMonitor monitor);
}
|
