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

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