← Back to branch summary

~vil/pydev/upstream

« back to all changes in this revision

Viewing changes to org.python.pydev/src/org/python/pydev/plugin/OverlayPreferenceStore.java

  • Committer: Vladimír Lapáček
  • Date: 2006-08-30 18:38:44 UTC
  • Revision ID: vladimir.lapacek@gmail.com-20060830183844-f4d82c1239a7770a
Initial import of upstream

Show diffs side-by-side

added added

removed removed

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