archive/net.sourceforge.phpeclipse.jtidy/src/net/sourceforge/phpdt/tidy/preferences/ResourcePreferenceStore.java

   1 /**
   2  * Created on 11.10.2002
   3  *
   4  * @author Jan Schulz
   5  */
   6 package net.sourceforge.phpdt.tidy.preferences;
   7
   8 import java.util.ArrayList;
   9 import java.util.List;
  10
  11 import org.eclipse.core.resources.IResource;
  12 import org.eclipse.core.runtime.CoreException;
  13 import org.eclipse.core.runtime.Platform;
  14 import org.eclipse.core.runtime.QualifiedName;
  15 import org.eclipse.jface.preference.IPreferenceStore;
  16 import org.eclipse.jface.preference.PreferenceStore;
  17 import org.eclipse.jface.resource.JFaceResources;
  18 import org.eclipse.jface.util.Assert;
  19 import org.eclipse.jface.util.IPropertyChangeListener;
  20 import org.eclipse.jface.util.ListenerList;
  21 import org.eclipse.jface.util.PropertyChangeEvent;
  22 import org.eclipse.jface.util.SafeRunnable;
  23
  24
  25 /**
  26  * This class can be used for wrapping a IResource to a PreferencePage
  27  *
  28  * Most of the class is C&P from the PreferenceStore which uses a Propertie
  29  * instance to store a the Properties.
  30  *
  31  *
  32  * @author Jan Schulz
  33  * @since 11.10.2002
  34  */
  35 public class ResourcePreferenceStore implements IPreferenceStore {
  36
  37         private IResource resource;
  38         private IPreferenceStore defaultValues = null;
  39         private String prefix;
  40
  41         private List unDefaulted = new ArrayList();
  42
  43         /**
  44          * List of registered listeners (element type: <code>IPropertyChangeListener</code>).
  45          * These listeners are to be informed when the current value of a preference changes.
  46          */
  47         private ListenerList listeners = new ListenerList();
  48
  49         /**
  50          * Indicates whether a value as been changed by <code>setToDefault</code>
  51          * or <code>setValue</code>; initially <code>false</code>.
  52          */
  53         private boolean dirty = false;
  54
  55         /**
  56          * <p>
  57          * Creates a IPreferenceStore were the Values are stored in a IResource
  58          * and the defaultValues are taken from a different IPreferenceStore
  59          * (like the default one of the plugin). If _defaultValues is empty, no
  60          * default values are present.
  61          * </p>
  62          * <p>
  63          * Because of the different mechanism for storeing Preferences, any
  64          * lookup for a preference with the given name will be 'translated' as
  65          * following:
  66          * </p><p>
  67          * <ul>
  68          * <li>The defaultValues are querried without prefix just with the given
  69          *     name</li>
  70          * <li>The Resource will be querried with the prefix and the name as a
  71          *     QualifiedName</li>
  72          * </ul>
  73          * </p><p>
  74          * Be carefull: even defaulted Properties are written into the underlying
  75          * resource!
  76          * @param _prefix -- String used as Qualifier
  77          * @param _resource -- a IResource, which may NOT be null
  78          * @param _defaultValues -- a IPreferenceStore or null
  79                  */
  80         public ResourcePreferenceStore(IResource _resource, String _prefix, IPreferenceStore _defaultValues) {
  81                 super();
  82                 Assert.isNotNull(_resource);
  83                 resource = _resource;
  84                 prefix = _prefix;
  85                 defaultValues = _defaultValues;
  86                 if (defaultValues == null) {
  87                         defaultValues = new PreferenceStore();
  88                 }
  89         }
  90
  91         public ResourcePreferenceStore(IResource _resource, String _prefix) {
  92                 this(_resource, _prefix, null);
  93         }
  94
  95         public ResourcePreferenceStore(IResource _resource) {
  96                 this(_resource, null, null);
  97         }
  98
  99         private QualifiedName getQNForName(String name) {
 100                 return new QualifiedName(prefix, name);
 101         }
 102
 103         private boolean resourceContains(String name) {
 104                 try {
 105                         return (resource.getPersistentProperty(getQNForName(name)) != null);
 106                 } catch (CoreException e) {
 107                         return false;
 108                 }
 109         }
 110
 111         private String getProperty(String name) {
 112                 try {
 113                         return resource.getPersistentProperty(getQNForName(name));
 114                 } catch (CoreException e) {
 115                 }
 116
 117                 return null;
 118         }
 119
 120         private void setProperty(String name, String value) {
 121                 try {
 122                         resource.setPersistentProperty(getQNForName(name), value);
 123                 } catch (CoreException e) {
 124                 }
 125
 126         }
 127
 128         /* (non-Javadoc)
 129          * Method declared on IPreferenceStore.
 130          */
 131         public void addPropertyChangeListener(IPropertyChangeListener listener) {
 132                 listeners.add(listener);
 133         }
 134         /* (non-Javadoc)
 135          * Method declared on IPreferenceStore.
 136          */
 137         public boolean contains(String name) {
 138                 return (resourceContains(name) || defaultValues.contains(name));
 139         }
 140         /* (non-Javadoc)
 141          * Method declared on IPreferenceStore.
 142          */
 143         public void firePropertyChangeEvent(String name, Object oldValue, Object newValue) {
 144                 final Object[] listeners = this.listeners.getListeners();
 145                 // Do we need to fire an event.
 146                 if (listeners.length > 0 && (oldValue == null || !oldValue.equals(newValue))) {
 147                         final PropertyChangeEvent pe = new PropertyChangeEvent(this, name, oldValue, newValue);
 148
 149                         Platform.run(new SafeRunnable(JFaceResources.getString("PreferenceStore.changeError")) { //$NON-NLS-1$
 150                                 public void run() {
 151                                         for (int i = 0; i < listeners.length; ++i) {
 152                                                 IPropertyChangeListener l = (IPropertyChangeListener) listeners[i];
 153                                                 l.propertyChange(pe);
 154                                         }
 155                                 }
 156                         });
 157                 }
 158         }
 159
 160         /**
 161          * Helper function: gets boolean for a given name.
 162          */
 163         public boolean getBoolean(String name) {
 164                 String value = getProperty(name);
 165                 if (value == null)
 166                         return BOOLEAN_DEFAULT_DEFAULT;
 167                 if (value.equals(IPreferenceStore.TRUE))
 168                         return true;
 169                 return false;
 170         }
 171         /* (non-Javadoc)
 172          * Method declared on IPreferenceStore.
 173          */
 174         public boolean getDefaultBoolean(String name) {
 175                 return defaultValues.getBoolean(name);
 176         }
 177         /* (non-Javadoc)
 178          * Method declared on IPreferenceStore.
 179          */
 180         public double getDefaultDouble(String name) {
 181                 return defaultValues.getDouble(name);
 182         }
 183         /* (non-Javadoc)
 184          * Method declared on IPreferenceStore.
 185          */
 186         public float getDefaultFloat(String name) {
 187                 return defaultValues.getFloat(name);
 188         }
 189         /* (non-Javadoc)
 190          * Method declared on IPreferenceStore.
 191          */
 192         public int getDefaultInt(String name) {
 193                 return defaultValues.getInt(name);
 194         }
 195         /* (non-Javadoc)
 196          * Method declared on IPreferenceStore.
 197          */
 198         public long getDefaultLong(String name) {
 199                 return defaultValues.getLong(name);
 200         }
 201         /* (non-Javadoc)
 202          * Method declared on IPreferenceStore.
 203          */
 204         public String getDefaultString(String name) {
 205                 return defaultValues.getString(name);
 206         }
 207
 208         public double getDouble(String name) {
 209                 String value = getProperty(name);
 210                 if (value == null)
 211                         return DOUBLE_DEFAULT_DEFAULT;
 212                 double ival = DOUBLE_DEFAULT_DEFAULT;
 213                 try {
 214                         ival = new Double(value).doubleValue();
 215                 } catch (NumberFormatException e) {
 216                 }
 217                 return ival;
 218         }
 219
 220         /**
 221         * Helper function: gets long for a given name.
 222         */
 223         public long getLong(String name) {
 224                 String value = getProperty(name);
 225                 if (value == null)
 226                         return LONG_DEFAULT_DEFAULT;
 227                 long ival = LONG_DEFAULT_DEFAULT;
 228                 try {
 229                         ival = Long.parseLong(value);
 230                 } catch (NumberFormatException e) {
 231                 }
 232                 return ival;
 233         }
 234         /* (non-Javadoc)
 235          * Method declared on IPreferenceStore.
 236          */
 237         public String getString(String name) {
 238                 String value = getProperty(name);
 239                 if (value == null)
 240                         return STRING_DEFAULT_DEFAULT;
 241                 return value;
 242         }
 243
 244         public float getFloat(String name) {
 245                 String value = getProperty(name);
 246                 if (value == null)
 247                         return FLOAT_DEFAULT_DEFAULT;
 248                 float ival = FLOAT_DEFAULT_DEFAULT;
 249                 try {
 250                         ival = new Float(value).floatValue();
 251                 } catch (NumberFormatException e) {
 252                 }
 253                 return ival;
 254         }
 255
 256         /* (non-Javadoc)
 257          * Method declared on IPreferenceStore.
 258          */
 259
 260         public int getInt(String name) {
 261                 String value = getProperty(name);
 262                 if (value == null)
 263                         return INT_DEFAULT_DEFAULT;
 264                 int ival = 0;
 265                 try {
 266                         ival = Integer.parseInt(value);
 267                 } catch (NumberFormatException e) {
 268                 }
 269                 return ival;
 270         }
 271
 272         /* (non-Javadoc)
 273          * Method declared on IPreferenceStore.
 274          */
 275         public boolean isDefault(String name) {
 276                 //REMIND: Is that the right algo?
 277                 return (!resourceContains(name) || getProperty(name).equals(defaultValues.getString(name)));
 278         }
 279
 280         /**
 281          * Indicates whether this PrefStore needds saving. As there isn't any saving
 282          * facility, it always returns false
 283          *
 284          * Method declared on IPreferenceStore.
 285          */
 286         public boolean needsSaving() {
 287                 return false;
 288         }
 289
 290         /* (non-Javadoc)
 291          * Method declared on IPreferenceStore.
 292          */
 293         public void putValue(String name, String value) {
 294                 String oldValue = getString(name);
 295                 if (oldValue == null || !oldValue.equals(value)) {
 296                         setValue(name, value);
 297                         dirty = true;
 298
 299                 }
 300         }
 301         /* (non-Javadoc)
 302          * Method declared on IPreferenceStore.
 303          */
 304         public void removePropertyChangeListener(IPropertyChangeListener listener) {
 305                 listeners.remove(listener);
 306         }
 307
 308         /* (non-Javadoc)
 309          * Method declared on IPreferenceStore.
 310          */
 311         public void setDefault(String name, double value) {
 312                 defaultValues.setValue(name, value);
 313         }
 314         /* (non-Javadoc)
 315          * Method declared on IPreferenceStore.
 316          */
 317         public void setDefault(String name, float value) {
 318                 defaultValues.setValue(name, value);
 319         }
 320         /* (non-Javadoc)
 321          * Method declared on IPreferenceStore.
 322          */
 323         public void setDefault(String name, int value) {
 324                 defaultValues.setValue(name, value);
 325         }
 326         /* (non-Javadoc)
 327          * Method declared on IPreferenceStore.
 328          */
 329         public void setDefault(String name, long value) {
 330                 defaultValues.setValue(name, value);
 331         }
 332         /* (non-Javadoc)
 333          * Method declared on IPreferenceStore.
 334          */
 335         public void setDefault(String name, String value) {
 336                 defaultValues.setValue(name, value);
 337         }
 338         /* (non-Javadoc)
 339          * Method declared on IPreferenceStore.
 340          */
 341         public void setDefault(String name, boolean value) {
 342                 defaultValues.setValue(name, value);
 343         }
 344
 345         /* (non-Javadoc)
 346          * Method declared on IPreferenceStore.
 347          */
 348         public void setToDefault(String name) {
 349                 Object oldValue = getProperty(name);
 350                 String newValue = null;
 351                 if (defaultValues != null)
 352                         newValue = (String) defaultValues.getString(name);
 353                 setProperty(name, newValue);
 354                 dirty = true;
 355
 356                 firePropertyChangeEvent(name, oldValue, newValue);
 357         }
 358         /* (non-Javadoc)
 359          * Method declared on IPreferenceStore.
 360          */
 361         public void setValue(String name, double value) {
 362                 double oldValue = getDouble(name);
 363                 if (oldValue != value) {
 364                         setProperty(name, Double.toString(value));
 365                         dirty = true;
 366                         firePropertyChangeEvent(name, new Double(oldValue), new Double(value));
 367                 }
 368         }
 369         /* (non-Javadoc)
 370          * Method declared on IPreferenceStore.
 371          */
 372         public void setValue(String name, float value) {
 373                 float oldValue = getFloat(name);
 374                 if (oldValue != value) {
 375                         setProperty(name, Float.toString(value));
 376                         dirty = true;
 377                         firePropertyChangeEvent(name, new Float(oldValue), new Float(value));
 378                 }
 379         }
 380         /* (non-Javadoc)
 381          * Method declared on IPreferenceStore.
 382          */
 383         public void setValue(String name, int value) {
 384                 int oldValue = getInt(name);
 385                 if (oldValue != value) {
 386                         setProperty(name, Integer.toString(value));
 387                         dirty = true;
 388                         firePropertyChangeEvent(name, new Integer(oldValue), new Integer(value));
 389                 }
 390         }
 391         /* (non-Javadoc)
 392          * Method declared on IPreferenceStore.
 393          */
 394         public void setValue(String name, long value) {
 395                 long oldValue = getLong(name);
 396                 if (oldValue != value) {
 397                         setProperty(name, Long.toString(value));
 398                         dirty = true;
 399                         firePropertyChangeEvent(name, new Long(oldValue), new Long(value));
 400                 }
 401         }
 402         /* (non-Javadoc)
 403          * Method declared on IPreferenceStore.
 404          */
 405         public void setValue(String name, String value) {
 406                 String oldValue = getString(name);
 407                 if (oldValue == null || !oldValue.equals(value)) {
 408                         setProperty(name, value);
 409                         dirty = true;
 410                         firePropertyChangeEvent(name, oldValue, value);
 411                 }
 412         }
 413         /* (non-Javadoc)
 414          * Method declared on IPreferenceStore.
 415          */
 416         public void setValue(String name, boolean value) {
 417                 boolean oldValue = getBoolean(name);
 418                 if (oldValue != value) {
 419                         setProperty(name, value == true ? IPreferenceStore.TRUE : IPreferenceStore.FALSE);
 420                         dirty = true;
 421                         firePropertyChangeEvent(name, new Boolean(oldValue), new Boolean(value));
 422                 }
 423         }
 424
 425 }