archive/net.sourceforge.phpeclipse.css.ui/src/net/sourceforge/phpeclipse/css/ui/internal/preferences/OverlayPreferenceStore.java

   1 /*
   2  * Copyright (c) 2003-2004 Christopher Lenz 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  *     Christopher Lenz - initial API and implementation
  10  *
  11  * $Id: OverlayPreferenceStore.java,v 1.1 2004-09-02 18:11:51 jsurfer Exp $
  12  */
  13
  14 package net.sourceforge.phpeclipse.css.ui.internal.preferences;
  15
  16 import java.util.ArrayList;
  17 import java.util.Iterator;
  18 import java.util.List;
  19
  20 import org.eclipse.jface.preference.IPreferenceStore;
  21 import org.eclipse.jface.preference.PreferenceStore;
  22 import org.eclipse.jface.util.IPropertyChangeListener;
  23 import org.eclipse.jface.util.PropertyChangeEvent;
  24
  25 public class OverlayPreferenceStore implements IPreferenceStore {
  26
  27         // Inner Classes -----------------------------------------------------------
  28
  29         /**
  30          * Descriptor used to denote data types.
  31          */
  32         public static final class Type {
  33                 protected Type() {
  34                 }
  35         }
  36
  37         /**
  38          * Data structure for the overlay key.
  39          */
  40         public static class OverlayKey {
  41
  42                 private Type fType;
  43                 private String fKey;
  44
  45                 public OverlayKey(Type type, String key) {
  46                         this.fType = type;
  47                         this.fKey = key;
  48                 }
  49         }
  50
  51         /**
  52          * @see IPropertyChangeListener
  53          */
  54         private class PropertyListener implements IPropertyChangeListener {
  55
  56                 /**
  57                  * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
  58                  */
  59                 public void propertyChange(PropertyChangeEvent event) {
  60                         OverlayKey key = findOverlayKey(event.getProperty());
  61                         if (key != null) {
  62                                 propagateProperty(fParent, key, fStore);
  63                         }
  64                 }
  65         }
  66
  67         // Constants ---------------------------------------------------------------
  68
  69         /**
  70          * Boolean property type.
  71          */
  72         public static final Type BOOLEAN = new Type();
  73
  74         /**
  75          * Double property type.
  76          */
  77         public static final Type DOUBLE = new Type();
  78
  79         /**
  80          * Floating point property type.
  81          */
  82         public static final Type FLOAT = new Type();
  83
  84         /**
  85          * Integer property type.
  86          */
  87         public static final Type INT = new Type();
  88
  89         /**
  90          * Long integer property type.
  91          */
  92         public static final Type LONG = new Type();
  93
  94         /**
  95          * String property type.
  96          */
  97         public static final Type STRING = new Type();
  98
  99         // Instance Variables ------------------------------------------------------
 100
 101         /**
 102          * The parent preference store.
 103          */
 104         private IPreferenceStore fParent;
 105
 106         /**
 107          * The underlying preference store.
 108          */
 109         private IPreferenceStore fStore;
 110
 111         /**
 112          * The keys of this store.
 113          */
 114         private List fOverlayKeys = new ArrayList();
 115
 116         /**
 117          * The property listener.
 118          */
 119         private PropertyListener fPropertyListener;
 120
 121         // Constructors ------------------------------------------------------------
 122
 123         /**
 124          * Creates and returns a new overlay preference store.
 125          *
 126          * @param parent the parent preference store
 127          */
 128         public OverlayPreferenceStore(IPreferenceStore parent) {
 129                 this.fParent = parent;
 130                 fStore = new PreferenceStore();
 131         }
 132
 133         // Public Methods ----------------------------------------------------------
 134
 135         public void addKey(Type type, String key) {
 136                 this.fOverlayKeys.add(new OverlayKey(type, key));
 137         }
 138         public void addBooleanKey(String key) {
 139                 addKey(BOOLEAN, key);
 140         }
 141         public void addDoubleKey(String key) {
 142                 addKey(DOUBLE, key);
 143         }
 144         public void addFloatKey(String key) {
 145                 addKey(FLOAT, key);
 146         }
 147         public void addIntKey(String key) {
 148                 addKey(INT, key);
 149         }
 150         public void addLongKey(String key) {
 151                 addKey(LONG, key);
 152         }
 153         public void addStringKey(String key) {
 154                 addKey(STRING, key);
 155         }
 156
 157         /**
 158          * Propagates all overlay keys from this store to the parent store.
 159          */
 160         public void propagate() {
 161                 for (Iterator i = fOverlayKeys.iterator(); i.hasNext(); ) {
 162                         propagateProperty(fStore, (OverlayKey) i.next(), fParent);
 163                 }
 164         }
 165
 166         /**
 167          * Loads the values from the parent into this store.
 168          */
 169         public void load() {
 170                 for (Iterator i = fOverlayKeys.iterator(); i.hasNext(); ) {
 171                         loadProperty(fParent, (OverlayKey) i.next(), fStore, true);
 172                 }
 173         }
 174
 175         /**
 176          * Loads the default values.
 177          */
 178         public void loadDefaults() {
 179                 for (Iterator i = fOverlayKeys.iterator(); i.hasNext(); ) {
 180                         setToDefault(((OverlayKey) i.next()).fKey);
 181                 }
 182         }
 183
 184         /**
 185          * Starts to listen for changes.
 186          */
 187         public void startListening() {
 188                 if (fPropertyListener == null) {
 189                         fPropertyListener = new PropertyListener();
 190                         fParent.addPropertyChangeListener(fPropertyListener);
 191                 }
 192         }
 193
 194         /**
 195          * Stops to listen for changes.
 196          */
 197         public void stopListening() {
 198                 if (fPropertyListener != null) {
 199                         fParent.removePropertyChangeListener(fPropertyListener);
 200                         fPropertyListener = null;
 201                 }
 202         }
 203
 204         // IPreferenceStore Implementation -----------------------------------------
 205
 206         /**
 207          * @see IPreferenceStore#addPropertyChangeListener(org.eclipse.jface.util.IPropertyChangeListener)
 208          */
 209         public void addPropertyChangeListener(IPropertyChangeListener listener) {
 210                 fStore.addPropertyChangeListener(listener);
 211         }
 212
 213         /**
 214          * @see IPreferenceStore#removePropertyChangeListener(org.eclipse.jface.util.IPropertyChangeListener)
 215          */
 216         public void removePropertyChangeListener(IPropertyChangeListener listener) {
 217                 fStore.removePropertyChangeListener(listener);
 218         }
 219
 220         /**
 221          * @see IPreferenceStore#firePropertyChangeEvent(java.lang.String, java.lang.Object, java.lang.Object)
 222          */
 223         public void firePropertyChangeEvent(String name, Object oldValue,
 224                 Object newValue) {
 225                 fStore.firePropertyChangeEvent(name, oldValue, newValue);
 226         }
 227
 228         /**
 229          * @see IPreferenceStore#contains(java.lang.String)
 230          */
 231         public boolean contains(String name) {
 232                 return fStore.contains(name);
 233         }
 234
 235         /**
 236          * @see IPreferenceStore#getBoolean(java.lang.String)
 237          */
 238         public boolean getBoolean(String name) {
 239                 return fStore.getBoolean(name);
 240         }
 241
 242         /**
 243          * @see IPreferenceStore#getDefaultBoolean(java.lang.String)
 244          */
 245         public boolean getDefaultBoolean(String name) {
 246                 return fStore.getDefaultBoolean(name);
 247         }
 248
 249         /**
 250          * @see IPreferenceStore#getDefaultDouble(java.lang.String)
 251          */
 252         public double getDefaultDouble(String name) {
 253                 return fStore.getDefaultDouble(name);
 254         }
 255
 256         /**
 257          * @see IPreferenceStore#getDefaultFloat(String)
 258          */
 259         public float getDefaultFloat(String name) {
 260                 return fStore.getDefaultFloat(name);
 261         }
 262
 263         /**
 264          * @see IPreferenceStore#getDefaultInt(String)
 265          */
 266         public int getDefaultInt(String name) {
 267                 return fStore.getDefaultInt(name);
 268         }
 269
 270         /**
 271          * @see IPreferenceStore#getDefaultLong(String)
 272          */
 273         public long getDefaultLong(String name) {
 274                 return fStore.getDefaultLong(name);
 275         }
 276
 277         /**
 278          * @see IPreferenceStore#getDefaultString(String)
 279          */
 280         public String getDefaultString(String name) {
 281                 return fStore.getDefaultString(name);
 282         }
 283
 284         /**
 285          * @see IPreferenceStore#getDouble(String)
 286          */
 287         public double getDouble(String name) {
 288                 return fStore.getDouble(name);
 289         }
 290
 291         /**
 292          * @see IPreferenceStore#getFloat(String)
 293          */
 294         public float getFloat(String name) {
 295                 return fStore.getFloat(name);
 296         }
 297
 298         /**
 299          * @see IPreferenceStore#getInt(String)
 300          */
 301         public int getInt(String name) {
 302                 return fStore.getInt(name);
 303         }
 304
 305         /**
 306          * @see IPreferenceStore#getLong(String)
 307          */
 308         public long getLong(String name) {
 309                 return fStore.getLong(name);
 310         }
 311
 312         /**
 313          * @see IPreferenceStore#getString(String)
 314          */
 315         public String getString(String name) {
 316                 return fStore.getString(name);
 317         }
 318
 319         /**
 320          * @see IPreferenceStore#isDefault(String)
 321          */
 322         public boolean isDefault(String name) {
 323                 return fStore.isDefault(name);
 324         }
 325
 326         /**
 327          * @see IPreferenceStore#needsSaving()
 328          */
 329         public boolean needsSaving() {
 330                 return fStore.needsSaving();
 331         }
 332
 333         /**
 334          * @see IPreferenceStore#putValue(String, String)
 335          */
 336         public void putValue(String name, String value) {
 337                 if (covers(name)) {
 338                         fStore.putValue(name, value);
 339                 }
 340         }
 341
 342         /**
 343          * @see IPreferenceStore#setDefault(String, double)
 344          */
 345         public void setDefault(String name, double value) {
 346                 if (covers(name)) {
 347                         fStore.setDefault(name, value);
 348                 }
 349         }
 350
 351         /**
 352          * @see IPreferenceStore#setDefault(String, float)
 353          */
 354         public void setDefault(String name, float value) {
 355                 if (covers(name)) {
 356                         fStore.setDefault(name, value);
 357                 }
 358         }
 359
 360         /**
 361          * @see IPreferenceStore#setDefault(String, int)
 362          */
 363         public void setDefault(String name, int value) {
 364                 if (covers(name)) {
 365                         fStore.setDefault(name, value);
 366                 }
 367         }
 368
 369         /**
 370          * @see IPreferenceStore#setDefault(String, long)
 371          */
 372         public void setDefault(String name, long value) {
 373                 if (covers(name)) {
 374                         fStore.setDefault(name, value);
 375                 }
 376         }
 377
 378         /**
 379          * @see IPreferenceStore#setDefault(String, String)
 380          */
 381         public void setDefault(String name, String value) {
 382                 if (covers(name)) {
 383                         fStore.setDefault(name, value);
 384                 }
 385         }
 386
 387         /**
 388          * @see IPreferenceStore#setDefault(String, boolean)
 389          */
 390         public void setDefault(String name, boolean value) {
 391                 if (covers(name)) {
 392                         fStore.setDefault(name, value);
 393                 }
 394         }
 395
 396         /**
 397          * @see IPreferenceStore#setToDefault(String)
 398          */
 399         public void setToDefault(String name) {
 400                 fStore.setToDefault(name);
 401         }
 402
 403         /**
 404          * @see IPreferenceStore#setValue(String, double)
 405          */
 406         public void setValue(String name, double value) {
 407                 if (covers(name)) {
 408                         fStore.setValue(name, value);
 409                 }
 410         }
 411
 412         /**
 413          * @see IPreferenceStore#setValue(String, float)
 414          */
 415         public void setValue(String name, float value) {
 416                 if (covers(name)) {
 417                         fStore.setValue(name, value);
 418                 }
 419         }
 420
 421         /**
 422          * @see IPreferenceStore#setValue(String, int)
 423          */
 424         public void setValue(String name, int value) {
 425                 if (covers(name)) {
 426                         fStore.setValue(name, value);
 427                 }
 428         }
 429
 430         /**
 431          * @see IPreferenceStore#setValue(String, long)
 432          */
 433         public void setValue(String name, long value) {
 434                 if (covers(name)) {
 435                         fStore.setValue(name, value);
 436                 }
 437         }
 438
 439         /**
 440          * @see IPreferenceStore#setValue(String, String)
 441          */
 442         public void setValue(String name, String value) {
 443                 if (covers(name)) {
 444                         fStore.setValue(name, value);
 445                 }
 446         }
 447
 448         /**
 449          * @see IPreferenceStore#setValue(String, boolean)
 450          */
 451         public void setValue(String name, boolean value) {
 452                 if (covers(name)) {
 453                         fStore.setValue(name, value);
 454                 }
 455         }
 456
 457         // Protected Methods -------------------------------------------------------
 458
 459         /**
 460          * Tries to find and return the overlay key for the given preference key
 461          * string.
 462          *
 463          * @param key the preference key string
 464          * @return the overlay key or <code>null</code> if none can be found
 465          */
 466         protected final OverlayKey findOverlayKey(String key) {
 467                 for (Iterator i = fOverlayKeys.iterator(); i.hasNext(); ) {
 468                         OverlayKey k = (OverlayKey) i.next();
 469                         if (k.fKey.equals(key)) {
 470                                 return k;
 471                         }
 472                 }
 473                 return null;
 474         }
 475
 476         /**
 477          * Propagates the given overlay key from the orgin to the target preference
 478          * store.
 479          *
 480          * @param origin the source preference store
 481          * @param key the overlay key
 482          * @param target the preference store to which the key is propagated
 483          */
 484         protected final void propagateProperty(IPreferenceStore origin,
 485                 OverlayKey key, IPreferenceStore target) {
 486                 if (origin.isDefault(key.fKey)) {
 487                         if (!target.isDefault(key.fKey)) {
 488                                 target.setToDefault(key.fKey);
 489                         }
 490                         return;
 491                 }
 492                 Type d = key.fType;
 493                 if (BOOLEAN == d) {
 494                         boolean originValue = origin.getBoolean(key.fKey);
 495                         boolean targetValue = target.getBoolean(key.fKey);
 496                         if (targetValue != originValue) {
 497                                 target.setValue(key.fKey, originValue);
 498                         }
 499                 } else if (DOUBLE == d) {
 500                         double originValue = origin.getDouble(key.fKey);
 501                         double targetValue = target.getDouble(key.fKey);
 502                         if (targetValue != originValue) {
 503                                 target.setValue(key.fKey, originValue);
 504                         }
 505                 } else if (FLOAT == d) {
 506                         float originValue = origin.getFloat(key.fKey);
 507                         float targetValue = target.getFloat(key.fKey);
 508                         if (targetValue != originValue) {
 509                                 target.setValue(key.fKey, originValue);
 510                         }
 511                 } else if (INT == d) {
 512                         int originValue = origin.getInt(key.fKey);
 513                         int targetValue = target.getInt(key.fKey);
 514                         if (targetValue != originValue) {
 515                                 target.setValue(key.fKey, originValue);
 516                         }
 517                 } else if (LONG == d) {
 518                         long originValue = origin.getLong(key.fKey);
 519                         long targetValue = target.getLong(key.fKey);
 520                         if (targetValue != originValue) {
 521                                 target.setValue(key.fKey, originValue);
 522                         }
 523                 } else if (STRING == d) {
 524                         String originValue = origin.getString(key.fKey);
 525                         String targetValue = target.getString(key.fKey);
 526                         if ((targetValue != null) && (originValue != null)
 527                          && !targetValue.equals(originValue)) {
 528                                 target.setValue(key.fKey, originValue);
 529                         }
 530                 }
 531         }
 532
 533         // Private Methods ---------------------------------------------------------
 534
 535         /**
 536          * Tells whether the given preference key string is
 537          * covered by this overlay store.
 538          *
 539          * @param key the preference key string
 540          * @return <code>true</code> if this overlay store covers the given key
 541          */
 542         private boolean covers(String key) {
 543                 return (findOverlayKey(key) != null);
 544         }
 545
 546         /**
 547          * Loads the given key from the orgin into the target.
 548          *
 549          * @param orgin the source preference store
 550          * @param key the overlay key
 551          * @param target the preference store to which the key is propagated
 552          * @param forceInitialization if <code>true</code> the value in the target
 553          *        gets initialized before loading
 554          */
 555         private void loadProperty(IPreferenceStore orgin, OverlayKey key,
 556                 IPreferenceStore target, boolean forceInitialization) {
 557                 Type d = key.fType;
 558                 if (BOOLEAN == d) {
 559                         if (forceInitialization) {
 560                                 target.setValue(key.fKey, true);
 561                         }
 562                         target.setValue(key.fKey, orgin.getBoolean(key.fKey));
 563                         target.setDefault(key.fKey, orgin.getDefaultBoolean(key.fKey));
 564                 } else if (DOUBLE == d) {
 565                         if (forceInitialization) {
 566                                 target.setValue(key.fKey, 1.0D);
 567                         }
 568                         target.setValue(key.fKey, orgin.getDouble(key.fKey));
 569                         target.setDefault(key.fKey, orgin.getDefaultDouble(key.fKey));
 570                 } else if (FLOAT == d) {
 571                         if (forceInitialization) {
 572                                 target.setValue(key.fKey, 1.0F);
 573                         }
 574                         target.setValue(key.fKey, orgin.getFloat(key.fKey));
 575                         target.setDefault(key.fKey, orgin.getDefaultFloat(key.fKey));
 576                 } else if (INT == d) {
 577                         if (forceInitialization) {
 578                                 target.setValue(key.fKey, 1);
 579                         }
 580                         target.setValue(key.fKey, orgin.getInt(key.fKey));
 581                         target.setDefault(key.fKey, orgin.getDefaultInt(key.fKey));
 582                 } else if (LONG == d) {
 583                         if (forceInitialization) {
 584                                 target.setValue(key.fKey, 1L);
 585                         }
 586                         target.setValue(key.fKey, orgin.getLong(key.fKey));
 587                         target.setDefault(key.fKey, orgin.getDefaultLong(key.fKey));
 588                 } else if (STRING == d) {
 589                         if (forceInitialization) {
 590                                 target.setValue(key.fKey, "1"); //$NON-NLS-1$
 591                         }
 592                         target.setValue(key.fKey, orgin.getString(key.fKey));
 593                         target.setDefault(key.fKey, orgin.getDefaultString(key.fKey));
 594                 }
 595         }
 596
 597 }