moving report handling related classes to own package + other minor changes.
[phpeclipse.git] / net.sourceforge.phpeclipse.ui / src / net / sourceforge / phpeclipse / ui / preferences / OverlayPreferenceStore.java
1 /*
2  * Copyright (c) 2002-2004 Widespace, OU and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Common Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://solareclipse.sourceforge.net/legal/cpl-v10.html
7  * 
8  * Contributors:
9  *     Igor Malinin - initial contribution
10  * 
11  * $Id: OverlayPreferenceStore.java,v 1.1 2004-09-02 18:26:30 jsurfer Exp $
12  */
13
14 package net.sourceforge.phpeclipse.ui.preferences;
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         private class PropertyListener implements IPropertyChangeListener {
27                 public void propertyChange(PropertyChangeEvent event) {
28                         PreferenceDescriptor key = findOverlayKey(event.getProperty());
29                         if (key != null) {
30                                 propagateProperty(parent, key, store);
31                         }
32                 }
33         }
34
35         IPreferenceStore parent;
36         IPreferenceStore store;
37
38         private PreferenceDescriptor[] keys;
39
40         private PropertyListener fPropertyListener;
41
42         public OverlayPreferenceStore(
43                 IPreferenceStore parent, PreferenceDescriptor[] overlayKeys
44         ) {
45                 this.parent = parent;
46                 this.keys = overlayKeys;
47
48                 store = new PreferenceStore();
49         }
50
51         PreferenceDescriptor findOverlayKey(String key) {
52                 for (int i = 0; i < keys.length; i++) {
53                         if (keys[i].key.equals(key)) {
54                                 return keys[i];
55                         }
56                 }
57
58                 return null;
59         }
60
61         private boolean covers(String key) {
62                 return (findOverlayKey(key) != null);
63         }
64
65         void propagateProperty(
66                 IPreferenceStore orgin, PreferenceDescriptor key,
67                 IPreferenceStore target
68         ) {
69                 if (orgin.isDefault(key.key)) {
70                         if (!target.isDefault(key.key)) {
71                                 target.setToDefault(key.key);
72                         }
73
74                         return;
75                 }
76
77                 PreferenceDescriptor.Type d = key.type;
78                 if (PreferenceDescriptor.BOOLEAN == d) {
79                         boolean originValue = orgin.getBoolean(key.key);
80                         boolean targetValue = target.getBoolean(key.key);
81                         if (targetValue != originValue) {
82                                 target.setValue(key.key, originValue);
83                         }
84                 } else if (PreferenceDescriptor.DOUBLE == d) {
85                         double originValue = orgin.getDouble(key.key);
86                         double targetValue = target.getDouble(key.key);
87                         if (targetValue != originValue) {
88                                 target.setValue(key.key, originValue);
89                         }
90                 } else if (PreferenceDescriptor.FLOAT == d) {
91                         float originValue = orgin.getFloat(key.key);
92                         float targetValue = target.getFloat(key.key);
93                         if (targetValue != originValue) {
94                                 target.setValue(key.key, originValue);
95                         }
96                 } else if (PreferenceDescriptor.INT == d) {
97                         int originValue = orgin.getInt(key.key);
98                         int targetValue = target.getInt(key.key);
99                         if (targetValue != originValue) {
100                                 target.setValue(key.key, originValue);
101                         }
102                 } else if (PreferenceDescriptor.LONG == d) {
103                         long originValue = orgin.getLong(key.key);
104                         long targetValue = target.getLong(key.key);
105                         if (targetValue != originValue) {
106                                 target.setValue(key.key, originValue);
107                         }
108                 } else if (PreferenceDescriptor.STRING == d) {
109                         String originValue = orgin.getString(key.key);
110                         String targetValue = target.getString(key.key);
111                         if (targetValue != null && originValue != null
112                                         && !targetValue.equals(originValue)) {
113                                 target.setValue(key.key, originValue);
114                         }
115                 }
116         }
117
118         public void propagate() {
119                 for (int i = 0; i < keys.length; i++) {
120                         propagateProperty(store, keys[i], parent);
121                 }
122         }
123
124         private void loadProperty(
125                 IPreferenceStore orgin, PreferenceDescriptor key,
126                 IPreferenceStore target, boolean forceInitialization
127         ) {
128                 PreferenceDescriptor.Type d = key.type;
129                 if (PreferenceDescriptor.BOOLEAN == d) {
130                         if (forceInitialization) {
131                                 target.setValue(key.key, true);
132                         }
133                         target.setValue(key.key, orgin.getBoolean(key.key));
134                         target.setDefault(key.key, orgin.getDefaultBoolean(key.key));
135                 } else if (PreferenceDescriptor.DOUBLE == d) {
136                         if (forceInitialization) {
137                                 target.setValue(key.key, 1.0D);
138                         }
139                         target.setValue(key.key, orgin.getDouble(key.key));
140                         target.setDefault(key.key, orgin.getDefaultDouble(key.key));
141                 } else if (PreferenceDescriptor.FLOAT == d) {
142                         if (forceInitialization) {
143                                 target.setValue(key.key, 1.0F);
144                         }
145                         target.setValue(key.key, orgin.getFloat(key.key));
146                         target.setDefault(key.key, orgin.getDefaultFloat(key.key));
147                 } else if (PreferenceDescriptor.INT == d) {
148                         if (forceInitialization) {
149                                 target.setValue(key.key, 1);
150                         }
151                         target.setValue(key.key, orgin.getInt(key.key));
152                         target.setDefault(key.key, orgin.getDefaultInt(key.key));
153                 } else if (PreferenceDescriptor.LONG == d) {
154                         if (forceInitialization) {
155                                 target.setValue(key.key, 1L);
156                         }
157                         target.setValue(key.key, orgin.getLong(key.key));
158                         target.setDefault(key.key, orgin.getDefaultLong(key.key));
159                 } else if (PreferenceDescriptor.STRING == d) {
160                         if (forceInitialization) {
161                                 target.setValue(key.key, "1"); //$NON-NLS-1$
162                         }
163                         target.setValue(key.key, orgin.getString(key.key));
164                         target.setDefault(key.key, orgin.getDefaultString(key.key));
165                 }
166         }
167
168         public void load() {
169                 for (int i = 0; i < keys.length; i++) {
170                         loadProperty(parent, keys[i], store, true);
171                 }
172         }
173
174         public void loadDefaults() {
175                 for (int i = 0; i < keys.length; i++) {
176                         setToDefault(keys[i].key);
177                 }
178         }
179
180         public void start() {
181                 if (fPropertyListener == null) {
182                         fPropertyListener = new PropertyListener();
183                         parent.addPropertyChangeListener(fPropertyListener);
184                 }
185         }
186
187         public void stop() {
188                 if (fPropertyListener != null) {
189                         parent.removePropertyChangeListener(fPropertyListener);
190                         fPropertyListener = null;
191                 }
192         }
193
194         /*
195          * @see IPreferenceStore#addPropertyChangeListener(IPropertyChangeListener)
196          */
197         public void addPropertyChangeListener(IPropertyChangeListener listener) {
198                 store.addPropertyChangeListener(listener);
199         }
200
201         /*
202          * @see IPreferenceStore#removePropertyChangeListener(IPropertyChangeListener)
203          */
204         public void removePropertyChangeListener(IPropertyChangeListener listener) {
205                 store.removePropertyChangeListener(listener);
206         }
207
208         /*
209          * @see IPreferenceStore#firePropertyChangeEvent(String, Object, Object)
210          */
211         public void firePropertyChangeEvent(
212                 String name, Object oldValue, Object newValue
213         ) {
214                 store.firePropertyChangeEvent(name, oldValue, newValue);
215         }
216
217         /*
218          * @see IPreferenceStore#contains(String)
219          */
220         public boolean contains(String name) {
221                 return store.contains(name);
222         }
223
224         /*
225          * @see IPreferenceStore#getBoolean(String)
226          */
227         public boolean getBoolean(String name) {
228                 return store.getBoolean(name);
229         }
230
231         /*
232          * @see IPreferenceStore#getDefaultBoolean(String)
233          */
234         public boolean getDefaultBoolean(String name) {
235                 return store.getDefaultBoolean(name);
236         }
237
238         /*
239          * @see IPreferenceStore#getDefaultDouble(String)
240          */
241         public double getDefaultDouble(String name) {
242                 return store.getDefaultDouble(name);
243         }
244
245         /*
246          * @see IPreferenceStore#getDefaultFloat(String)
247          */
248         public float getDefaultFloat(String name) {
249                 return store.getDefaultFloat(name);
250         }
251
252         /*
253          * @see IPreferenceStore#getDefaultInt(String)
254          */
255         public int getDefaultInt(String name) {
256                 return store.getDefaultInt(name);
257         }
258
259         /*
260          * @see IPreferenceStore#getDefaultLong(String)
261          */
262         public long getDefaultLong(String name) {
263                 return store.getDefaultLong(name);
264         }
265
266         /*
267          * @see IPreferenceStore#getDefaultString(String)
268          */
269         public String getDefaultString(String name) {
270                 return store.getDefaultString(name);
271         }
272
273         /*
274          * @see IPreferenceStore#getDouble(String)
275          */
276         public double getDouble(String name) {
277                 return store.getDouble(name);
278         }
279
280         /*
281          * @see IPreferenceStore#getFloat(String)
282          */
283         public float getFloat(String name) {
284                 return store.getFloat(name);
285         }
286
287         /*
288          * @see IPreferenceStore#getInt(String)
289          */
290         public int getInt(String name) {
291                 return store.getInt(name);
292         }
293
294         /*
295          * @see IPreferenceStore#getLong(String)
296          */
297         public long getLong(String name) {
298                 return store.getLong(name);
299         }
300
301         /*
302          * @see IPreferenceStore#getString(String)
303          */
304         public String getString(String name) {
305                 return store.getString(name);
306         }
307
308         /*
309          * @see IPreferenceStore#isDefault(String)
310          */
311         public boolean isDefault(String name) {
312                 return store.isDefault(name);
313         }
314
315         /*
316          * @see IPreferenceStore#needsSaving()
317          */
318         public boolean needsSaving() {
319                 return store.needsSaving();
320         }
321
322         /*
323          * @see IPreferenceStore#putValue(String, String)
324          */
325         public void putValue(String name, String value) {
326                 if (covers(name)) {
327                         store.putValue(name, value);
328                 }
329         }
330
331         /*
332          * @see IPreferenceStore#setDefault(String, double)
333          */
334         public void setDefault(String name, double value) {
335                 if (covers(name)) {
336                         store.setDefault(name, value);
337                 }
338         }
339
340         /*
341          * @see IPreferenceStore#setDefault(String, float)
342          */
343         public void setDefault(String name, float value) {
344                 if (covers(name)) {
345                         store.setDefault(name, value);
346                 }
347         }
348
349         /*
350          * @see IPreferenceStore#setDefault(String, int)
351          */
352         public void setDefault(String name, int value) {
353                 if (covers(name)) {
354                         store.setDefault(name, value);
355                 }
356         }
357
358         /*
359          * @see IPreferenceStore#setDefault(String, long)
360          */
361         public void setDefault(String name, long value) {
362                 if (covers(name)) {
363                         store.setDefault(name, value);
364                 }
365         }
366
367         /*
368          * @see IPreferenceStore#setDefault(String, String)
369          */
370         public void setDefault(String name, String value) {
371                 if (covers(name)) {
372                         store.setDefault(name, value);
373                 }
374         }
375
376         /*
377          * @see IPreferenceStore#setDefault(String, boolean)
378          */
379         public void setDefault(String name, boolean value) {
380                 if (covers(name)) {
381                         store.setDefault(name, value);
382                 }
383         }
384
385         /*
386          * @see IPreferenceStore#setToDefault(String)
387          */
388         public void setToDefault(String name) {
389                 store.setToDefault(name);
390         }
391
392         /*
393          * @see IPreferenceStore#setValue(String, double)
394          */
395         public void setValue(String name, double value) {
396                 if (covers(name)) {
397                         store.setValue(name, value);
398                 }
399         }
400
401         /*
402          * @see IPreferenceStore#setValue(String, float)
403          */
404         public void setValue(String name, float value) {
405                 if (covers(name)) {
406                         store.setValue(name, value);
407                 }
408         }
409
410         /*
411          * @see IPreferenceStore#setValue(String, int)
412          */
413         public void setValue(String name, int value) {
414                 if (covers(name)) {
415                         store.setValue(name, value);
416                 }
417         }
418
419         /*
420          * @see IPreferenceStore#setValue(String, long)
421          */
422         public void setValue(String name, long value) {
423                 if (covers(name)) {
424                         store.setValue(name, value);
425                 }
426         }
427
428         /*
429          * @see IPreferenceStore#setValue(String, String)
430          */
431         public void setValue(String name, String value) {
432                 if (covers(name)) {
433                         store.setValue(name, value);
434                 }
435         }
436
437         /*
438          * @see IPreferenceStore#setValue(String, boolean)
439          */
440         public void setValue(String name, boolean value) {
441                 if (covers(name)) {
442                         store.setValue(name, value);
443                 }
444         }
445 }