net.sourceforge.phpeclipse.ui/src/net/sourceforge/phpeclipse/preferences/OverlayPreferenceStore.java

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