Java tutorial
/******************************************************************************* * Copyright (c) 2000, 2005 IBM Corporation and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * IBM Corporation - initial API and implementation *******************************************************************************/ package com.architexa.org.eclipse.gef.ui.palette; import com.architexa.org.eclipse.gef.internal.InternalGEFPlugin; import java.beans.PropertyChangeListener; import java.beans.PropertyChangeSupport; import org.eclipse.swt.graphics.FontData; import org.eclipse.jface.preference.IPreferenceStore; import org.eclipse.jface.resource.JFaceResources; import org.eclipse.jface.util.IPropertyChangeListener; import org.eclipse.jface.util.PropertyChangeEvent; /** * This is the default implementation for PaletteViewerPreferences. It uses * a single IPreferenceStore to load and save the palette viewer settings. * <p> * It is recommended that the default constructor be used (which will use the preference * store in the GEF plugin) as that will cause the preferences to be shared across * different types of editors. If the client does not wish to share one of the existing * preferences for their editor (say the auto-collapse setting), they will have to * sub-class this class and override the necessary methods (in this case, {@link * #getAutoCollapseSetting()} and {@link #setAutoCollapseSetting(int)}) and save that * preference in some other preference store. Sub-classes can add newer preferences to * the store by using {@link #getPreferenceStore()}. * </p> * * @author Pratik Shah */ public class DefaultPaletteViewerPreferences implements PaletteViewerPreferences { private static final String DEFAULT_FONT = "Default"; //$NON-NLS-1$ private PreferenceStoreListener listener; private IPropertyChangeListener fontListener; private FontData fontData; private PropertyChangeSupport listeners = new PropertyChangeSupport(this); private IPreferenceStore store; private int[] supportedModes = { LAYOUT_COLUMNS, LAYOUT_LIST, LAYOUT_ICONS, LAYOUT_DETAILS }; /** * Default Constructor * <p> * Uses the GEF Plugin's IPreferenceStore to store the preferences. * </p> */ public DefaultPaletteViewerPreferences() { this(InternalGEFPlugin.getDefault().getPreferenceStore()); } /** * Constructor * * @param store The IPreferenceStore where the settings are to be saved. */ public DefaultPaletteViewerPreferences(final IPreferenceStore store) { this.store = store; store.setDefault(PREFERENCE_DETAILS_ICON_SIZE, false); store.setDefault(PREFERENCE_COLUMNS_ICON_SIZE, true); store.setDefault(PREFERENCE_ICONS_ICON_SIZE, true); store.setDefault(PREFERENCE_LIST_ICON_SIZE, false); store.setDefault(PREFERENCE_LAYOUT, LAYOUT_LIST); store.setDefault(PREFERENCE_AUTO_COLLAPSE, COLLAPSE_AS_NEEDED); store.setDefault(PREFERENCE_FONT, DEFAULT_FONT); listener = new PreferenceStoreListener(); store.addPropertyChangeListener(listener); fontListener = new IPropertyChangeListener() { public void propertyChange(PropertyChangeEvent event) { if (JFaceResources.DIALOG_FONT.equals(event.getProperty())) { if (getPreferenceStore().getString(PREFERENCE_FONT).equals(DEFAULT_FONT)) { setFontData(JFaceResources.getDialogFont().getFontData()[0]); handlePreferenceStorePropertyChanged(PREFERENCE_FONT); } } } }; JFaceResources.getFontRegistry().addListener(fontListener); } /** * NOTE: The <code>oldValue</code> field of the <code>PropertyChangeEvent</code> used to * notify listeners will always be <code>null</code>. * * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#addPropertyChangeListener( * PropertyChangeListener) */ public void addPropertyChangeListener(PropertyChangeListener listener) { listeners.addPropertyChangeListener(listener); } /** * This is a convenience method that converts the given layout mode to the matching * preference name. * * <UL> * <LI> int <-> String </LI> * <LI> LAYOUT_LIST <-> PREFERENCE_LIST_ICON_SIZE </LI> * <LI> LAYOUT_COLUMNS <-> PREFERENCE_COLUMNS_ICON_SIZE </LI> * <LI> LAYOUT_ICONS <-> PREFERENCE_ICONS_ICON_SIZE </LI> * <LI> LAYOUT_DETAILS <-> PREFERENCE_DETAILS_ICON_SIZE </LI> * </UL> * * @param layout LAYOUT_LIST, LAYOUT_DETAILS, LAYOUT_COLUMNS, or LAYOUT_ICONS * @return The corresponding preference String */ public static String convertLayoutToPreferenceName(int layout) { String key = ""; //$NON-NLS-1$ switch (layout) { case LAYOUT_COLUMNS: key = PREFERENCE_COLUMNS_ICON_SIZE; break; case LAYOUT_LIST: key = PREFERENCE_LIST_ICON_SIZE; break; case LAYOUT_ICONS: key = PREFERENCE_ICONS_ICON_SIZE; break; case LAYOUT_DETAILS: key = PREFERENCE_DETAILS_ICON_SIZE; break; } return key; } /** * This convenience method converts the given preference to the matching layout mode. * * <UL> * <LI> int <-> String </LI> * <LI> LAYOUT_LIST <-> PREFERENCE_LIST_ICON_SIZE </LI> * <LI> LAYOUT_COLUMNS <-> PREFERENCE_COLUMNS_ICON_SIZE </LI> * <LI> LAYOUT_ICONS <-> PREFERENCE_ICONS_ICON_SIZE </LI> * <LI> LAYOUT_DETAILS <-> PREFERENCE_DETAILS_ICON_SIZE </LI> * </UL> * * @param preference PREFERENCE_DETAILS_ICON_SIZE, PREFERENCE_COLUMNS_ICON_SIZE, * PREFERENCE_ICONS_ICON_SIZE or PREFERENCE_LIST_ICON_SIZE * @return The corresponding layout code */ public static int convertPreferenceNameToLayout(String preference) { int layout = -1; if (preference.equals(PREFERENCE_DETAILS_ICON_SIZE)) { layout = LAYOUT_DETAILS; } else if (preference.equals(PREFERENCE_COLUMNS_ICON_SIZE)) { layout = LAYOUT_COLUMNS; } else if (preference.equals(PREFERENCE_ICONS_ICON_SIZE)) { layout = LAYOUT_ICONS; } else if (preference.equals(PREFERENCE_LIST_ICON_SIZE)) { layout = LAYOUT_LIST; } return layout; } /** * The oldValue of the PropertyChangeEvent that is fired will always be <code>null</code>. * * @param property The programmatic name of the property that was changed * @param newVal The new value of the property * @see java.beans.PropertyChangeSupport#firePropertyChange(java.lang.String, * java.lang.Object, * java.lang.Object) */ protected void firePropertyChanged(String property, Object newVal) { listeners.firePropertyChange(property, null, newVal); } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#getAutoCollapseSetting() */ public int getAutoCollapseSetting() { return getPreferenceStore().getInt(PREFERENCE_AUTO_COLLAPSE); } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#getFontData() */ public FontData getFontData() { if (fontData == null) { String value = getPreferenceStore().getString(PREFERENCE_FONT); if (value.equals(DEFAULT_FONT)) { fontData = JFaceResources.getDialogFont().getFontData()[0]; } else { fontData = new FontData(value); } } return fontData; } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#getLayoutSetting() */ public int getLayoutSetting() { return getPreferenceStore().getInt(PREFERENCE_LAYOUT); } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#getSupportedLayoutModes() */ public int[] getSupportedLayoutModes() { return supportedModes; } /** * This method is invoked when the preference store fires a property change. * * @param property The property String used for the change fired by the preference * store */ protected void handlePreferenceStorePropertyChanged(String property) { if (property.equals(PREFERENCE_LAYOUT)) { firePropertyChanged(property, new Integer(getLayoutSetting())); } else if (property.equals(PREFERENCE_AUTO_COLLAPSE)) { firePropertyChanged(property, new Integer(getAutoCollapseSetting())); } else if (property.equals(PREFERENCE_FONT)) { firePropertyChanged(property, getFontData()); } else { firePropertyChanged(property, new Boolean(useLargeIcons(convertPreferenceNameToLayout(property)))); } } /** * @return The IPreferenceStore used by this class to store the preferences. */ protected IPreferenceStore getPreferenceStore() { return store; } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#isSupportedLayoutMode(int) */ public boolean isSupportedLayoutMode(int layout) { for (int i = 0; i < supportedModes.length; i++) { if (supportedModes[i] == layout) { return true; } } return false; } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#removePropertyChangeListener( * PropertyChangeListener) */ public void removePropertyChangeListener(PropertyChangeListener listener) { listeners.removePropertyChangeListener(listener); } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#setAutoCollapseSetting(int) */ public void setAutoCollapseSetting(int newVal) { getPreferenceStore().setValue(PREFERENCE_AUTO_COLLAPSE, newVal); } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#setFontData(FontData) */ public void setFontData(FontData data) { fontData = data; String value = data.toString(); if (fontData.equals(JFaceResources.getDialogFont().getFontData()[0])) { value = DEFAULT_FONT; } getPreferenceStore().setValue(PREFERENCE_FONT, value); } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#setLayoutSetting(int) */ public void setLayoutSetting(int newVal) { getPreferenceStore().setValue(PREFERENCE_LAYOUT, newVal); } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#setCurrentUseLargeIcons( * boolean) */ public void setCurrentUseLargeIcons(boolean newVal) { setUseLargeIcons(getLayoutSetting(), newVal); } /** * NOTE: Restricting the layout modes here does not in any way restrict those values from * being stored in the preference store. Instead, it is the responsibility of all clients * manipulating the layout settings to check to see if a particular layout mode is * supported before manipulating it, or allowing the end user to manipulate it. * * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#setSupportedLayoutModes(int[]) */ public void setSupportedLayoutModes(int[] modes) { supportedModes = modes; if (!isSupportedLayoutMode(getPreferenceStore().getDefaultInt(PREFERENCE_LAYOUT))) { getPreferenceStore().setDefault(PREFERENCE_LAYOUT, supportedModes[0]); } if (!isSupportedLayoutMode(getPreferenceStore().getInt(PREFERENCE_LAYOUT))) { setLayoutSetting(supportedModes[0]); } } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#setUseLargeIcons(int, boolean) */ public void setUseLargeIcons(int layout, boolean newVal) { getPreferenceStore().setValue(convertLayoutToPreferenceName(layout), newVal); } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#useLargeIcons(int) */ public boolean useLargeIcons(int layout) { return getPreferenceStore().getBoolean(convertLayoutToPreferenceName(layout)); } /** * @see com.architexa.org.eclipse.gef.ui.palette.PaletteViewerPreferences#useLargeIcons() */ public boolean useLargeIcons() { return useLargeIcons(getLayoutSetting()); } private class PreferenceStoreListener implements IPropertyChangeListener { /** * @see org.eclipse.jface.util.IPropertyChangeListener#propertyChange(org.eclipse.jface.util.PropertyChangeEvent) */ public void propertyChange(PropertyChangeEvent evt) { handlePreferenceStorePropertyChanged(evt.getProperty()); } } }