001: /*******************************************************************************
002: * Copyright (c) 2000, 2006 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jdt.internal.ui.preferences;
011:
012: import org.eclipse.core.runtime.Assert;
013:
014: import org.eclipse.jface.preference.IPreferenceStore;
015: import org.eclipse.jface.preference.PreferenceStore;
016: import org.eclipse.jface.util.IPropertyChangeListener;
017: import org.eclipse.jface.util.PropertyChangeEvent;
018:
019: /**
020: * An overlaying preference store.
021: */
022: public class OverlayPreferenceStore implements IPreferenceStore {
023:
024: public static final class TypeDescriptor {
025: private TypeDescriptor() {
026: }
027: }
028:
029: public static final TypeDescriptor BOOLEAN = new TypeDescriptor();
030: public static final TypeDescriptor DOUBLE = new TypeDescriptor();
031: public static final TypeDescriptor FLOAT = new TypeDescriptor();
032: public static final TypeDescriptor INT = new TypeDescriptor();
033: public static final TypeDescriptor LONG = new TypeDescriptor();
034: public static final TypeDescriptor STRING = new TypeDescriptor();
035:
036: public static class OverlayKey {
037:
038: TypeDescriptor fDescriptor;
039: String fKey;
040:
041: public OverlayKey(TypeDescriptor descriptor, String key) {
042: fDescriptor = descriptor;
043: fKey = key;
044: }
045: }
046:
047: private class PropertyListener implements IPropertyChangeListener {
048:
049: /*
050: * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
051: */
052: public void propertyChange(PropertyChangeEvent event) {
053: OverlayKey key = findOverlayKey(event.getProperty());
054: if (key != null)
055: propagateProperty(fParent, key, fStore);
056: }
057: }
058:
059: private IPreferenceStore fParent;
060: private IPreferenceStore fStore;
061: private OverlayKey[] fOverlayKeys;
062:
063: private PropertyListener fPropertyListener;
064: private boolean fLoaded;
065:
066: public OverlayPreferenceStore(IPreferenceStore parent,
067: OverlayKey[] overlayKeys) {
068: fParent = parent;
069: fOverlayKeys = overlayKeys;
070: fStore = new PreferenceStore();
071: }
072:
073: private OverlayKey findOverlayKey(String key) {
074: for (int i = 0; i < fOverlayKeys.length; i++) {
075: if (fOverlayKeys[i].fKey.equals(key))
076: return fOverlayKeys[i];
077: }
078: return null;
079: }
080:
081: private boolean covers(String key) {
082: return (findOverlayKey(key) != null);
083: }
084:
085: private void propagateProperty(IPreferenceStore orgin,
086: OverlayKey key, IPreferenceStore target) {
087:
088: if (orgin.isDefault(key.fKey)) {
089: if (!target.isDefault(key.fKey))
090: target.setToDefault(key.fKey);
091: return;
092: }
093:
094: TypeDescriptor d = key.fDescriptor;
095: if (BOOLEAN == d) {
096:
097: boolean originValue = orgin.getBoolean(key.fKey);
098: boolean targetValue = target.getBoolean(key.fKey);
099: if (targetValue != originValue)
100: target.setValue(key.fKey, originValue);
101:
102: } else if (DOUBLE == d) {
103:
104: double originValue = orgin.getDouble(key.fKey);
105: double targetValue = target.getDouble(key.fKey);
106: if (targetValue != originValue)
107: target.setValue(key.fKey, originValue);
108:
109: } else if (FLOAT == d) {
110:
111: float originValue = orgin.getFloat(key.fKey);
112: float targetValue = target.getFloat(key.fKey);
113: if (targetValue != originValue)
114: target.setValue(key.fKey, originValue);
115:
116: } else if (INT == d) {
117:
118: int originValue = orgin.getInt(key.fKey);
119: int targetValue = target.getInt(key.fKey);
120: if (targetValue != originValue)
121: target.setValue(key.fKey, originValue);
122:
123: } else if (LONG == d) {
124:
125: long originValue = orgin.getLong(key.fKey);
126: long targetValue = target.getLong(key.fKey);
127: if (targetValue != originValue)
128: target.setValue(key.fKey, originValue);
129:
130: } else if (STRING == d) {
131:
132: String originValue = orgin.getString(key.fKey);
133: String targetValue = target.getString(key.fKey);
134: if (targetValue != null && originValue != null
135: && !targetValue.equals(originValue))
136: target.setValue(key.fKey, originValue);
137:
138: }
139: }
140:
141: public void propagate() {
142: for (int i = 0; i < fOverlayKeys.length; i++)
143: propagateProperty(fStore, fOverlayKeys[i], fParent);
144: }
145:
146: private void loadProperty(IPreferenceStore orgin, OverlayKey key,
147: IPreferenceStore target, boolean forceInitialization) {
148: TypeDescriptor d = key.fDescriptor;
149: if (BOOLEAN == d) {
150:
151: if (forceInitialization)
152: target.setValue(key.fKey, true);
153: target.setValue(key.fKey, orgin.getBoolean(key.fKey));
154: target.setDefault(key.fKey, orgin
155: .getDefaultBoolean(key.fKey));
156:
157: } else if (DOUBLE == d) {
158:
159: if (forceInitialization)
160: target.setValue(key.fKey, 1.0D);
161: target.setValue(key.fKey, orgin.getDouble(key.fKey));
162: target.setDefault(key.fKey, orgin
163: .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
171: .setDefault(key.fKey, orgin
172: .getDefaultFloat(key.fKey));
173:
174: } else if (INT == d) {
175:
176: if (forceInitialization)
177: target.setValue(key.fKey, 1);
178: target.setValue(key.fKey, orgin.getInt(key.fKey));
179: target.setDefault(key.fKey, orgin.getDefaultInt(key.fKey));
180:
181: } else if (LONG == d) {
182:
183: if (forceInitialization)
184: target.setValue(key.fKey, 1L);
185: target.setValue(key.fKey, orgin.getLong(key.fKey));
186: target.setDefault(key.fKey, orgin.getDefaultLong(key.fKey));
187:
188: } else if (STRING == d) {
189:
190: if (forceInitialization)
191: target.setValue(key.fKey, "1"); //$NON-NLS-1$
192: target.setValue(key.fKey, orgin.getString(key.fKey));
193: target.setDefault(key.fKey, orgin
194: .getDefaultString(key.fKey));
195:
196: }
197: }
198:
199: public void load() {
200: for (int i = 0; i < fOverlayKeys.length; i++)
201: loadProperty(fParent, fOverlayKeys[i], fStore, true);
202:
203: fLoaded = true;
204:
205: }
206:
207: public void loadDefaults() {
208: for (int i = 0; i < fOverlayKeys.length; i++)
209: setToDefault(fOverlayKeys[i].fKey);
210: }
211:
212: public void start() {
213: if (fPropertyListener == null) {
214: fPropertyListener = new PropertyListener();
215: fParent.addPropertyChangeListener(fPropertyListener);
216: }
217: }
218:
219: public void stop() {
220: if (fPropertyListener != null) {
221: fParent.removePropertyChangeListener(fPropertyListener);
222: fPropertyListener = null;
223: }
224: }
225:
226: /*
227: * @see IPreferenceStore#addPropertyChangeListener(IPropertyChangeListener)
228: */
229: public void addPropertyChangeListener(
230: IPropertyChangeListener listener) {
231: fStore.addPropertyChangeListener(listener);
232: }
233:
234: /*
235: * @see IPreferenceStore#removePropertyChangeListener(IPropertyChangeListener)
236: */
237: public void removePropertyChangeListener(
238: IPropertyChangeListener listener) {
239: fStore.removePropertyChangeListener(listener);
240: }
241:
242: /*
243: * @see IPreferenceStore#firePropertyChangeEvent(String, Object, Object)
244: */
245: public void firePropertyChangeEvent(String name, Object oldValue,
246: Object newValue) {
247: fStore.firePropertyChangeEvent(name, oldValue, newValue);
248: }
249:
250: /*
251: * @see IPreferenceStore#contains(String)
252: */
253: public boolean contains(String name) {
254: return fStore.contains(name);
255: }
256:
257: /*
258: * @see IPreferenceStore#getBoolean(String)
259: */
260: public boolean getBoolean(String name) {
261: return fStore.getBoolean(name);
262: }
263:
264: /*
265: * @see IPreferenceStore#getDefaultBoolean(String)
266: */
267: public boolean getDefaultBoolean(String name) {
268: return fStore.getDefaultBoolean(name);
269: }
270:
271: /*
272: * @see IPreferenceStore#getDefaultDouble(String)
273: */
274: public double getDefaultDouble(String name) {
275: return fStore.getDefaultDouble(name);
276: }
277:
278: /*
279: * @see IPreferenceStore#getDefaultFloat(String)
280: */
281: public float getDefaultFloat(String name) {
282: return fStore.getDefaultFloat(name);
283: }
284:
285: /*
286: * @see IPreferenceStore#getDefaultInt(String)
287: */
288: public int getDefaultInt(String name) {
289: return fStore.getDefaultInt(name);
290: }
291:
292: /*
293: * @see IPreferenceStore#getDefaultLong(String)
294: */
295: public long getDefaultLong(String name) {
296: return fStore.getDefaultLong(name);
297: }
298:
299: /*
300: * @see IPreferenceStore#getDefaultString(String)
301: */
302: public String getDefaultString(String name) {
303: return fStore.getDefaultString(name);
304: }
305:
306: /*
307: * @see IPreferenceStore#getDouble(String)
308: */
309: public double getDouble(String name) {
310: return fStore.getDouble(name);
311: }
312:
313: /*
314: * @see IPreferenceStore#getFloat(String)
315: */
316: public float getFloat(String name) {
317: return fStore.getFloat(name);
318: }
319:
320: /*
321: * @see IPreferenceStore#getInt(String)
322: */
323: public int getInt(String name) {
324: return fStore.getInt(name);
325: }
326:
327: /*
328: * @see IPreferenceStore#getLong(String)
329: */
330: public long getLong(String name) {
331: return fStore.getLong(name);
332: }
333:
334: /*
335: * @see IPreferenceStore#getString(String)
336: */
337: public String getString(String name) {
338: return fStore.getString(name);
339: }
340:
341: /*
342: * @see IPreferenceStore#isDefault(String)
343: */
344: public boolean isDefault(String name) {
345: return fStore.isDefault(name);
346: }
347:
348: /*
349: * @see IPreferenceStore#needsSaving()
350: */
351: public boolean needsSaving() {
352: return fStore.needsSaving();
353: }
354:
355: /*
356: * @see IPreferenceStore#putValue(String, String)
357: */
358: public void putValue(String name, String value) {
359: if (covers(name))
360: fStore.putValue(name, value);
361: }
362:
363: /*
364: * @see IPreferenceStore#setDefault(String, double)
365: */
366: public void setDefault(String name, double value) {
367: if (covers(name))
368: fStore.setDefault(name, value);
369: }
370:
371: /*
372: * @see IPreferenceStore#setDefault(String, float)
373: */
374: public void setDefault(String name, float value) {
375: if (covers(name))
376: fStore.setDefault(name, value);
377: }
378:
379: /*
380: * @see IPreferenceStore#setDefault(String, int)
381: */
382: public void setDefault(String name, int value) {
383: if (covers(name))
384: fStore.setDefault(name, value);
385: }
386:
387: /*
388: * @see IPreferenceStore#setDefault(String, long)
389: */
390: public void setDefault(String name, long value) {
391: if (covers(name))
392: fStore.setDefault(name, value);
393: }
394:
395: /*
396: * @see IPreferenceStore#setDefault(String, String)
397: */
398: public void setDefault(String name, String value) {
399: if (covers(name))
400: fStore.setDefault(name, value);
401: }
402:
403: /*
404: * @see IPreferenceStore#setDefault(String, boolean)
405: */
406: public void setDefault(String name, boolean value) {
407: if (covers(name))
408: fStore.setDefault(name, value);
409: }
410:
411: /*
412: * @see IPreferenceStore#setToDefault(String)
413: */
414: public void setToDefault(String name) {
415: fStore.setToDefault(name);
416: }
417:
418: /*
419: * @see IPreferenceStore#setValue(String, double)
420: */
421: public void setValue(String name, double value) {
422: if (covers(name))
423: fStore.setValue(name, value);
424: }
425:
426: /*
427: * @see IPreferenceStore#setValue(String, float)
428: */
429: public void setValue(String name, float value) {
430: if (covers(name))
431: fStore.setValue(name, value);
432: }
433:
434: /*
435: * @see IPreferenceStore#setValue(String, int)
436: */
437: public void setValue(String name, int value) {
438: if (covers(name))
439: fStore.setValue(name, value);
440: }
441:
442: /*
443: * @see IPreferenceStore#setValue(String, long)
444: */
445: public void setValue(String name, long value) {
446: if (covers(name))
447: fStore.setValue(name, value);
448: }
449:
450: /*
451: * @see IPreferenceStore#setValue(String, String)
452: */
453: public void setValue(String name, String value) {
454: if (covers(name))
455: fStore.setValue(name, value);
456: }
457:
458: /*
459: * @see IPreferenceStore#setValue(String, boolean)
460: */
461: public void setValue(String name, boolean value) {
462: if (covers(name))
463: fStore.setValue(name, value);
464: }
465:
466: /**
467: * The keys to add to the list of overlay keys.
468: * <p>
469: * Note: This method must be called before {@link #load()} is called.
470: * </p>
471: *
472: * @param keys
473: * @since 3.0
474: */
475: public void addKeys(OverlayKey[] keys) {
476: Assert.isTrue(!fLoaded);
477: Assert.isNotNull(keys);
478:
479: int overlayKeysLength = fOverlayKeys.length;
480: OverlayKey[] result = new OverlayKey[keys.length
481: + overlayKeysLength];
482:
483: for (int i = 0, length = overlayKeysLength; i < length; i++)
484: result[i] = fOverlayKeys[i];
485:
486: for (int i = 0, length = keys.length; i < length; i++)
487: result[overlayKeysLength + i] = keys[i];
488:
489: fOverlayKeys = result;
490:
491: if (fLoaded)
492: load();
493: }
494: }
|