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
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
|
/*
* java.beans.VetoableChangeSupport: part of the Java Class Libraries project.
* Copyright (C) 1998 Free Software Foundation
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
package java.beans;
import java.util.Hashtable;
import java.util.Vector;
/**
** VetoableChangeSupport makes it easy to fire vetoable
** change events and handle listeners as well as reversion
** of old values when things go wrong.
**
** @author John Keiser
** @since JDK1.1
** @version 1.2.0, 15 Mar 1998
**/
public class VetoableChangeSupport implements java.io.Serializable {
Hashtable propertyListeners = new Hashtable();
Vector listeners = new Vector();
Object bean;
/** Create VetoableChangeSupport to work with a specific
** source bean.
** @param bean the source bean to use.
**/
public VetoableChangeSupport(Object bean) {
this.bean = bean;
}
/** Adds a VetoableChangeListener to the list of listeners.
** All property change events will be sent to this listener.
** <P>
**
** The listener add is not unique: that is, <em>n</em> adds with
** the same listener will result in <em>n</em> events being sent
** to that listener for every property change.
** <P>
**
** Adding a null listener will cause undefined behavior.
**
** @param l the listener to add.
**/
public void addVetoableChangeListener(VetoableChangeListener l) {
listeners.addElement(l);
}
/** Adds a VetoableChangeListener listening on the specified property.
** Events will be sent to the listener for that particular property.
** <P>
**
** The listener add is not unique; that is, <em>n</em> adds on a
** particular property for a particular listener will result in
** <em>n</em> events being sent to that listener when that
** property is changed.
** <P>
**
** The effect is cumulative, too; if you are registered to listen
** to receive events on all property changes, and then you
** register on a particular property, you will receive change
** events for that property twice.
** <P>
**
** Adding a null listener will cause undefined behavior.
**
** @param propertyName the name of the property to listen on.
** @param l the listener to add.
**/
public void addVetoableChangeListener(String propertyName, VetoableChangeListener l) {
synchronized(propertyListeners) {
Vector v = (Vector)propertyListeners.get(propertyName);
try {
v.addElement(l);
} catch(NullPointerException e) {
/* If v is not found, create a new vector. */
v = new Vector();
v.addElement(l);
propertyListeners.put(propertyName, v);
}
}
}
/** Removes a VetoableChangeListener from the list of listeners.
** If any specific properties are being listened on, they must
** be deregistered by themselves; this will only remove the
** general listener to all properties.
** <P>
**
** If <code>add()</code> has been called multiple times for a
** particular listener, <code>remove()</code> will have to be
** called the same number of times to deregister it.
**
** @param l the listener to remove.
**/
public void removeVetoableChangeListener(VetoableChangeListener l) {
listeners.removeElement(l);
}
/** Removes a VetoableChangeListener from listening to a specific property.
** <P>
**
** If <code>add()</code> has been called multiple times for a
** particular listener on a property, <code>remove()</code> will
** have to be called the same number of times to deregister it.
**
** @param propertyName the property to stop listening on.
** @param l the listener to remove.
**/
public void removeVetoableChangeListener(String propertyName, VetoableChangeListener l) {
synchronized(propertyListeners) {
Vector v = (Vector)propertyListeners.get(propertyName);
try {
v.removeElement(l);
if(v.size() == 0) {
propertyListeners.remove(propertyName);
}
} catch(NullPointerException e) {
/* if v is not found, do nothing. */
}
}
}
/** Fire a VetoableChangeEvent to all the listeners.
** If any listener objects, a reversion event will be sent to
** those listeners who received the initial event.
**
** @param proposedChange the event to send.
** @exception PropertyVetoException if the change is vetoed.
**/
public void fireVetoableChange(PropertyChangeEvent proposedChange) throws PropertyVetoException {
int currentListener=0;
try {
for(;currentListener<listeners.size();currentListener++) {
((VetoableChangeListener)listeners.elementAt(currentListener)).vetoableChange(proposedChange);
}
} catch(PropertyVetoException e) {
PropertyChangeEvent reversion = new PropertyChangeEvent(proposedChange.getSource(),proposedChange.getPropertyName(),proposedChange.getNewValue(),proposedChange.getOldValue());
for(int sendAgain=0;sendAgain<currentListener;sendAgain++) {
try {
((VetoableChangeListener)listeners.elementAt(sendAgain)).vetoableChange(reversion);
} catch(PropertyVetoException e2) {
}
}
throw e;
}
Vector moreListeners = (Vector)propertyListeners.get(proposedChange.getPropertyName());
if(moreListeners != null) {
try {
for(currentListener = 0; currentListener < moreListeners.size(); currentListener++) {
((VetoableChangeListener)moreListeners.elementAt(currentListener)).vetoableChange(proposedChange);
}
} catch(PropertyVetoException e) {
PropertyChangeEvent reversion = new PropertyChangeEvent(proposedChange.getSource(),proposedChange.getPropertyName(),proposedChange.getNewValue(),proposedChange.getOldValue());
for(int sendAgain=0;sendAgain<listeners.size();sendAgain++) {
try {
((VetoableChangeListener)listeners.elementAt(currentListener)).vetoableChange(proposedChange);
} catch(PropertyVetoException e2) {
}
}
for(int sendAgain=0;sendAgain<currentListener;sendAgain++) {
try {
((VetoableChangeListener)moreListeners.elementAt(sendAgain)).vetoableChange(reversion);
} catch(PropertyVetoException e2) {
}
}
throw e;
}
}
}
/** Fire a VetoableChangeEvent containing the old and new values of the property to all the listeners.
** If any listener objects, a reversion event will be sent to
** those listeners who received the initial event.
**
** @param propertyName the name of the property that
** changed.
** @param oldVal the old value.
** @param newVal the new value.
** @exception PropertyVetoException if the change is vetoed.
**/
public void fireVetoableChange(String propertyName, Object oldVal, Object newVal) throws PropertyVetoException {
fireVetoableChange(new PropertyChangeEvent(bean,propertyName,oldVal,newVal));
}
/** Fire a VetoableChangeEvent containing the old and new values of the property to all the listeners.
** If any listener objects, a reversion event will be sent to
** those listeners who received the initial event.
**
** @param propertyName the name of the property that
** changed.
** @param oldVal the old value.
** @param newVal the new value.
** @exception PropertyVetoException if the change is vetoed.
**/
public void fireVetoableChange(String propertyName, boolean oldVal, boolean newVal) throws PropertyVetoException {
fireVetoableChange(new PropertyChangeEvent(bean,propertyName,new Boolean(oldVal),new Boolean(newVal)));
}
/** Fire a VetoableChangeEvent containing the old and new values of the property to all the listeners.
** If any listener objects, a reversion event will be sent to
** those listeners who received the initial event.
**
** @param propertyName the name of the property that
** changed.
** @param oldVal the old value.
** @param newVal the new value.
** @exception PropertyVetoException if the change is vetoed.
**/
public void fireVetoableChange(String propertyName, int oldVal, int newVal) throws PropertyVetoException {
fireVetoableChange(new PropertyChangeEvent(bean,propertyName,new Integer(oldVal),new Integer(newVal)));
}
/** Tell whether the specified property is being listened on or not.
** This will only return <code>true</code> if there are listeners
** on all properties or if there is a listener specifically on this
** property.
**
** @param propertyName the property that may be listened on
** @return whether the property is being listened on
**/
public boolean hasListeners(String propertyName) {
return listeners.size() > 0 || propertyListeners.get(propertyName) != null;
}
}
|
