]>
Commit | Line | Data |
---|---|---|
1b2798f6 EK |
1 | /******************************************************************************* |
2 | * Copyright (c) 2000, 2008 IBM Corporation and others. | |
3 | * All rights reserved. This program and the accompanying materials | |
4 | * are made available under the terms of the Eclipse Public License v1.0 | |
5 | * which accompanies this distribution, and is available at | |
6 | * http://www.eclipse.org/legal/epl-v10.html | |
7 | * | |
8 | * Contributors: | |
9 | * IBM Corporation - initial API and implementation | |
10 | *******************************************************************************/ | |
11 | ||
12 | package org.eclipse.jdt.internal.ui.preferences; | |
13 | ||
14 | import org.eclipse.core.runtime.Assert; | |
15 | ||
16 | import org.eclipse.jface.preference.IPreferenceStore; | |
17 | import org.eclipse.jface.preference.PreferenceStore; | |
18 | import org.eclipse.jface.util.IPropertyChangeListener; | |
19 | import org.eclipse.jface.util.PropertyChangeEvent; | |
20 | ||
21 | ||
22 | /** | |
23 | * An overlaying preference store. | |
24 | */ | |
25 | public class OverlayPreferenceStore implements IPreferenceStore { | |
26 | ||
27 | ||
28 | public static final class TypeDescriptor { | |
29 | private TypeDescriptor() { | |
30 | } | |
31 | } | |
32 | ||
33 | public static final TypeDescriptor BOOLEAN= new TypeDescriptor(); | |
34 | public static final TypeDescriptor DOUBLE= new TypeDescriptor(); | |
35 | public static final TypeDescriptor FLOAT= new TypeDescriptor(); | |
36 | public static final TypeDescriptor INT= new TypeDescriptor(); | |
37 | public static final TypeDescriptor LONG= new TypeDescriptor(); | |
38 | public static final TypeDescriptor STRING= new TypeDescriptor(); | |
39 | ||
40 | public static class OverlayKey { | |
41 | ||
42 | TypeDescriptor fDescriptor; | |
43 | String fKey; | |
44 | ||
45 | public OverlayKey(TypeDescriptor descriptor, String key) { | |
46 | fDescriptor= descriptor; | |
47 | fKey= key; | |
48 | } | |
49 | } | |
50 | ||
51 | private class PropertyListener implements IPropertyChangeListener { | |
52 | ||
53 | /* | |
54 | * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent) | |
55 | */ | |
56 | public void propertyChange(PropertyChangeEvent event) { | |
57 | OverlayKey key= findOverlayKey(event.getProperty()); | |
58 | if (key != null) | |
59 | propagateProperty(fParent, key, fStore); | |
60 | } | |
61 | } | |
62 | ||
63 | ||
64 | private IPreferenceStore fParent; | |
65 | private IPreferenceStore fStore; | |
66 | private OverlayKey[] fOverlayKeys; | |
67 | ||
68 | private PropertyListener fPropertyListener; | |
69 | private boolean fLoaded; | |
70 | ||
71 | ||
72 | public OverlayPreferenceStore(IPreferenceStore parent, OverlayKey[] overlayKeys) { | |
73 | fParent= parent; | |
74 | fOverlayKeys= overlayKeys; | |
75 | fStore= new PreferenceStore(); | |
76 | } | |
77 | ||
78 | private OverlayKey findOverlayKey(String key) { | |
79 | for (int i= 0; i < fOverlayKeys.length; i++) { | |
80 | if (fOverlayKeys[i].fKey.equals(key)) | |
81 | return fOverlayKeys[i]; | |
82 | } | |
83 | return null; | |
84 | } | |
85 | ||
86 | private boolean covers(String key) { | |
87 | return (findOverlayKey(key) != null); | |
88 | } | |
89 | ||
90 | private void propagateProperty(IPreferenceStore orgin, OverlayKey key, IPreferenceStore target) { | |
91 | ||
92 | if (orgin.isDefault(key.fKey)) { | |
93 | if (!target.isDefault(key.fKey)) | |
94 | target.setToDefault(key.fKey); | |
95 | return; | |
96 | } | |
97 | ||
98 | TypeDescriptor d= key.fDescriptor; | |
99 | if (BOOLEAN == d) { | |
100 | ||
101 | boolean originValue= orgin.getBoolean(key.fKey); | |
102 | boolean targetValue= target.getBoolean(key.fKey); | |
103 | if (targetValue != originValue) | |
104 | target.setValue(key.fKey, originValue); | |
105 | ||
106 | } else if (DOUBLE == d) { | |
107 | ||
108 | double originValue= orgin.getDouble(key.fKey); | |
109 | double targetValue= target.getDouble(key.fKey); | |
110 | if (targetValue != originValue) | |
111 | target.setValue(key.fKey, originValue); | |
112 | ||
113 | } else if (FLOAT == d) { | |
114 | ||
115 | float originValue= orgin.getFloat(key.fKey); | |
116 | float targetValue= target.getFloat(key.fKey); | |
117 | if (targetValue != originValue) | |
118 | target.setValue(key.fKey, originValue); | |
119 | ||
120 | } else if (INT == d) { | |
121 | ||
122 | int originValue= orgin.getInt(key.fKey); | |
123 | int targetValue= target.getInt(key.fKey); | |
124 | if (targetValue != originValue) | |
125 | target.setValue(key.fKey, originValue); | |
126 | ||
127 | } else if (LONG == d) { | |
128 | ||
129 | long originValue= orgin.getLong(key.fKey); | |
130 | long targetValue= target.getLong(key.fKey); | |
131 | if (targetValue != originValue) | |
132 | target.setValue(key.fKey, originValue); | |
133 | ||
134 | } else if (STRING == d) { | |
135 | ||
136 | String originValue= orgin.getString(key.fKey); | |
137 | String targetValue= target.getString(key.fKey); | |
138 | if (targetValue != null && originValue != null && !targetValue.equals(originValue)) | |
139 | target.setValue(key.fKey, originValue); | |
140 | ||
141 | } | |
142 | } | |
143 | ||
144 | public void propagate() { | |
145 | for (int i= 0; i < fOverlayKeys.length; i++) | |
146 | propagateProperty(fStore, fOverlayKeys[i], fParent); | |
147 | } | |
148 | ||
149 | private void loadProperty(IPreferenceStore orgin, OverlayKey key, IPreferenceStore target, boolean forceInitialization) { | |
150 | TypeDescriptor d= key.fDescriptor; | |
151 | if (BOOLEAN == d) { | |
152 | ||
153 | if (forceInitialization) | |
154 | target.setValue(key.fKey, true); | |
155 | target.setValue(key.fKey, orgin.getBoolean(key.fKey)); | |
156 | target.setDefault(key.fKey, orgin.getDefaultBoolean(key.fKey)); | |
157 | ||
158 | } else if (DOUBLE == d) { | |
159 | ||
160 | if (forceInitialization) | |
161 | target.setValue(key.fKey, 1.0D); | |
162 | target.setValue(key.fKey, orgin.getDouble(key.fKey)); | |
163 | target.setDefault(key.fKey, orgin.getDefaultDouble(key.fKey)); | |
164 | ||
165 | } else if (FLOAT == d) { | |
166 | ||
167 | if (forceInitialization) | |
168 | target.setValue(key.fKey, 1.0F); | |
169 | target.setValue(key.fKey, orgin.getFloat(key.fKey)); | |
170 | target.setDefault(key.fKey, orgin.getDefaultFloat(key.fKey)); | |
171 | ||
172 | } else if (INT == d) { | |
173 | ||
174 | if (forceInitialization) | |
175 | target.setValue(key.fKey, 1); | |
176 | target.setValue(key.fKey, orgin.getInt(key.fKey)); | |
177 | target.setDefault(key.fKey, orgin.getDefaultInt(key.fKey)); | |
178 | ||
179 | } else if (LONG == d) { | |
180 | ||
181 | if (forceInitialization) | |
182 | target.setValue(key.fKey, 1L); | |
183 | target.setValue(key.fKey, orgin.getLong(key.fKey)); | |
184 | target.setDefault(key.fKey, orgin.getDefaultLong(key.fKey)); | |
185 | ||
186 | } else if (STRING == d) { | |
187 | ||
188 | if (forceInitialization) | |
189 | target.setValue(key.fKey, "1"); //$NON-NLS-1$ | |
190 | target.setValue(key.fKey, orgin.getString(key.fKey)); | |
191 | target.setDefault(key.fKey, orgin.getDefaultString(key.fKey)); | |
192 | ||
193 | } | |
194 | } | |
195 | ||
196 | public void load() { | |
197 | for (int i= 0; i < fOverlayKeys.length; i++) | |
198 | loadProperty(fParent, fOverlayKeys[i], fStore, true); | |
199 | ||
200 | fLoaded= true; | |
201 | ||
202 | } | |
203 | ||
204 | public void loadDefaults() { | |
205 | for (int i= 0; i < fOverlayKeys.length; i++) | |
206 | setToDefault(fOverlayKeys[i].fKey); | |
207 | } | |
208 | ||
209 | public void start() { | |
210 | if (fPropertyListener == null) { | |
211 | fPropertyListener= new PropertyListener(); | |
212 | fParent.addPropertyChangeListener(fPropertyListener); | |
213 | } | |
214 | } | |
215 | ||
216 | public void stop() { | |
217 | if (fPropertyListener != null) { | |
218 | fParent.removePropertyChangeListener(fPropertyListener); | |
219 | fPropertyListener= null; | |
220 | } | |
221 | } | |
222 | ||
223 | /* | |
224 | * @see IPreferenceStore#addPropertyChangeListener(IPropertyChangeListener) | |
225 | */ | |
226 | public void addPropertyChangeListener(IPropertyChangeListener listener) { | |
227 | fStore.addPropertyChangeListener(listener); | |
228 | } | |
229 | ||
230 | /* | |
231 | * @see IPreferenceStore#removePropertyChangeListener(IPropertyChangeListener) | |
232 | */ | |
233 | public void removePropertyChangeListener(IPropertyChangeListener listener) { | |
234 | fStore.removePropertyChangeListener(listener); | |
235 | } | |
236 | ||
237 | /* | |
238 | * @see IPreferenceStore#firePropertyChangeEvent(String, Object, Object) | |
239 | */ | |
240 | public void firePropertyChangeEvent(String name, Object oldValue, Object newValue) { | |
241 | fStore.firePropertyChangeEvent(name, oldValue, newValue); | |
242 | } | |
243 | ||
244 | /* | |
245 | * @see IPreferenceStore#contains(String) | |
246 | */ | |
247 | public boolean contains(String name) { | |
248 | return fStore.contains(name); | |
249 | } | |
250 | ||
251 | /* | |
252 | * @see IPreferenceStore#getBoolean(String) | |
253 | */ | |
254 | public boolean getBoolean(String name) { | |
255 | return fStore.getBoolean(name); | |
256 | } | |
257 | ||
258 | /* | |
259 | * @see IPreferenceStore#getDefaultBoolean(String) | |
260 | */ | |
261 | public boolean getDefaultBoolean(String name) { | |
262 | return fStore.getDefaultBoolean(name); | |
263 | } | |
264 | ||
265 | /* | |
266 | * @see IPreferenceStore#getDefaultDouble(String) | |
267 | */ | |
268 | public double getDefaultDouble(String name) { | |
269 | return fStore.getDefaultDouble(name); | |
270 | } | |
271 | ||
272 | /* | |
273 | * @see IPreferenceStore#getDefaultFloat(String) | |
274 | */ | |
275 | public float getDefaultFloat(String name) { | |
276 | return fStore.getDefaultFloat(name); | |
277 | } | |
278 | ||
279 | /* | |
280 | * @see IPreferenceStore#getDefaultInt(String) | |
281 | */ | |
282 | public int getDefaultInt(String name) { | |
283 | return fStore.getDefaultInt(name); | |
284 | } | |
285 | ||
286 | /* | |
287 | * @see IPreferenceStore#getDefaultLong(String) | |
288 | */ | |
289 | public long getDefaultLong(String name) { | |
290 | return fStore.getDefaultLong(name); | |
291 | } | |
292 | ||
293 | /* | |
294 | * @see IPreferenceStore#getDefaultString(String) | |
295 | */ | |
296 | public String getDefaultString(String name) { | |
297 | return fStore.getDefaultString(name); | |
298 | } | |
299 | ||
300 | /* | |
301 | * @see IPreferenceStore#getDouble(String) | |
302 | */ | |
303 | public double getDouble(String name) { | |
304 | return fStore.getDouble(name); | |
305 | } | |
306 | ||
307 | /* | |
308 | * @see IPreferenceStore#getFloat(String) | |
309 | */ | |
310 | public float getFloat(String name) { | |
311 | return fStore.getFloat(name); | |
312 | } | |
313 | ||
314 | /* | |
315 | * @see IPreferenceStore#getInt(String) | |
316 | */ | |
317 | public int getInt(String name) { | |
318 | return fStore.getInt(name); | |
319 | } | |
320 | ||
321 | /* | |
322 | * @see IPreferenceStore#getLong(String) | |
323 | */ | |
324 | public long getLong(String name) { | |
325 | return fStore.getLong(name); | |
326 | } | |
327 | ||
328 | /* | |
329 | * @see IPreferenceStore#getString(String) | |
330 | */ | |
331 | public String getString(String name) { | |
332 | return fStore.getString(name); | |
333 | } | |
334 | ||
335 | /* | |
336 | * @see IPreferenceStore#isDefault(String) | |
337 | */ | |
338 | public boolean isDefault(String name) { | |
339 | return fStore.isDefault(name); | |
340 | } | |
341 | ||
342 | /* | |
343 | * @see IPreferenceStore#needsSaving() | |
344 | */ | |
345 | public boolean needsSaving() { | |
346 | return fStore.needsSaving(); | |
347 | } | |
348 | ||
349 | /* | |
350 | * @see IPreferenceStore#putValue(String, String) | |
351 | */ | |
352 | public void putValue(String name, String value) { | |
353 | if (covers(name)) | |
354 | fStore.putValue(name, value); | |
355 | } | |
356 | ||
357 | /* | |
358 | * @see IPreferenceStore#setDefault(String, double) | |
359 | */ | |
360 | public void setDefault(String name, double value) { | |
361 | if (covers(name)) | |
362 | fStore.setDefault(name, value); | |
363 | } | |
364 | ||
365 | /* | |
366 | * @see IPreferenceStore#setDefault(String, float) | |
367 | */ | |
368 | public void setDefault(String name, float value) { | |
369 | if (covers(name)) | |
370 | fStore.setDefault(name, value); | |
371 | } | |
372 | ||
373 | /* | |
374 | * @see IPreferenceStore#setDefault(String, int) | |
375 | */ | |
376 | public void setDefault(String name, int value) { | |
377 | if (covers(name)) | |
378 | fStore.setDefault(name, value); | |
379 | } | |
380 | ||
381 | /* | |
382 | * @see IPreferenceStore#setDefault(String, long) | |
383 | */ | |
384 | public void setDefault(String name, long value) { | |
385 | if (covers(name)) | |
386 | fStore.setDefault(name, value); | |
387 | } | |
388 | ||
389 | /* | |
390 | * @see IPreferenceStore#setDefault(String, String) | |
391 | */ | |
392 | public void setDefault(String name, String value) { | |
393 | if (covers(name)) | |
394 | fStore.setDefault(name, value); | |
395 | } | |
396 | ||
397 | /* | |
398 | * @see IPreferenceStore#setDefault(String, boolean) | |
399 | */ | |
400 | public void setDefault(String name, boolean value) { | |
401 | if (covers(name)) | |
402 | fStore.setDefault(name, value); | |
403 | } | |
404 | ||
405 | /* | |
406 | * @see IPreferenceStore#setToDefault(String) | |
407 | */ | |
408 | public void setToDefault(String name) { | |
409 | fStore.setToDefault(name); | |
410 | } | |
411 | ||
412 | /* | |
413 | * @see IPreferenceStore#setValue(String, double) | |
414 | */ | |
415 | public void setValue(String name, double value) { | |
416 | if (covers(name)) | |
417 | fStore.setValue(name, value); | |
418 | } | |
419 | ||
420 | /* | |
421 | * @see IPreferenceStore#setValue(String, float) | |
422 | */ | |
423 | public void setValue(String name, float value) { | |
424 | if (covers(name)) | |
425 | fStore.setValue(name, value); | |
426 | } | |
427 | ||
428 | /* | |
429 | * @see IPreferenceStore#setValue(String, int) | |
430 | */ | |
431 | public void setValue(String name, int value) { | |
432 | if (covers(name)) | |
433 | fStore.setValue(name, value); | |
434 | } | |
435 | ||
436 | /* | |
437 | * @see IPreferenceStore#setValue(String, long) | |
438 | */ | |
439 | public void setValue(String name, long value) { | |
440 | if (covers(name)) | |
441 | fStore.setValue(name, value); | |
442 | } | |
443 | ||
444 | /* | |
445 | * @see IPreferenceStore#setValue(String, String) | |
446 | */ | |
447 | public void setValue(String name, String value) { | |
448 | if (covers(name)) | |
449 | fStore.setValue(name, value); | |
450 | } | |
451 | ||
452 | /* | |
453 | * @see IPreferenceStore#setValue(String, boolean) | |
454 | */ | |
455 | public void setValue(String name, boolean value) { | |
456 | if (covers(name)) | |
457 | fStore.setValue(name, value); | |
458 | } | |
459 | ||
460 | /** | |
461 | * The keys to add to the list of overlay keys. | |
462 | * <p> | |
463 | * Note: This method must be called before {@link #load()} is called. | |
464 | * </p> | |
465 | * | |
466 | * @param keys | |
467 | * @since 3.0 | |
468 | */ | |
469 | public void addKeys(OverlayKey[] keys) { | |
470 | Assert.isTrue(!fLoaded); | |
471 | Assert.isNotNull(keys); | |
472 | ||
473 | int overlayKeysLength= fOverlayKeys.length; | |
474 | OverlayKey[] result= new OverlayKey[keys.length + overlayKeysLength]; | |
475 | ||
476 | for (int i= 0, length= overlayKeysLength; i < length; i++) | |
477 | result[i]= fOverlayKeys[i]; | |
478 | ||
479 | for (int i= 0, length= keys.length; i < length; i++) | |
480 | result[overlayKeysLength + i]= keys[i]; | |
481 | ||
482 | fOverlayKeys= result; | |
483 | ||
484 | if (fLoaded) | |
485 | load(); | |
486 | } | |
487 | } |