/*******************************************************************************
* Copyright (c) 2000, 2009 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 org.eclipse.compare;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.eclipse.compare.internal.CompareContainer;
import org.eclipse.compare.internal.ComparePreferencePage;
import org.eclipse.compare.internal.CompareUIPlugin;
import org.eclipse.compare.internal.DiffImageDescriptor;
import org.eclipse.compare.internal.ICompareUIConstants;
import org.eclipse.compare.rangedifferencer.RangeDifference;
import org.eclipse.compare.structuremergeviewer.Differencer;
import org.eclipse.compare.structuremergeviewer.ICompareInput;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.resource.LocalResourceManager;
import org.eclipse.jface.resource.ResourceManager;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.LabelProviderChangedEvent;
import org.eclipse.swt.graphics.Image;
/**
* A <code>CompareConfiguration</code> object
* controls various UI aspects of compare/merge viewers like
* title labels and images, or whether a side of a merge viewer is editable.
* In addition to these fixed properties <code>ICompareConfiguration</code> provides
* API for an open ended set of properties. Different viewers which share the same
* configuration can communicate via this mechanism. E.g. if a compare editor
* has a button for controlling whether compare viewers ignore white space,
* the button would trigger a change of the boolean <code>IGNORE_WHITESPACE</code> property
* and all interested viewers would receive notification.
* <p>
* Suitable default labels are provided (without images); both the left and right sides
* are editable.
* </p>
* <p>
* Clients may use this class as is, or subclass to add new state and behavior.
* </p>
*/
public class CompareConfiguration {
/**
* Name of the ignore whitespace property (value <code>"IGNORE_WHITESPACE"</code>).
*/
public static final String IGNORE_WHITESPACE= "IGNORE_WHITESPACE"; //$NON-NLS-1$
/**
* Name of the show pseudo conflicts property (value <code>"SHOW_PSEUDO_CONFLICTS"</code>).
*/
public static final String SHOW_PSEUDO_CONFLICTS= "SHOW_PSEUDO_CONFLICTS"; //$NON-NLS-1$
/**
* Name of the use outline view property (value <code>"USE_OUTLINE_VIEW"</code>).
* @since 3.0
*/
public static final String USE_OUTLINE_VIEW= "USE_OUTLINE_VIEW"; //$NON-NLS-1$
private static ImageDescriptor[] fgImages= new ImageDescriptor[16];
private static boolean fLeftIsLocal= true;
static {
if (fLeftIsLocal) {
fgImages[Differencer.ADDITION]= CompareUIPlugin.getImageDescriptor("ovr16/del_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.LEFT + Differencer.ADDITION]= CompareUIPlugin.getImageDescriptor("ovr16/r_inadd_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.RIGHT + Differencer.ADDITION]= CompareUIPlugin.getImageDescriptor("ovr16/r_outadd_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.DELETION]= CompareUIPlugin.getImageDescriptor("ovr16/add_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.LEFT + Differencer.DELETION]= CompareUIPlugin.getImageDescriptor("ovr16/r_indel_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.RIGHT + Differencer.DELETION]= CompareUIPlugin.getImageDescriptor("ovr16/r_outdel_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.LEFT + Differencer.CHANGE]= CompareUIPlugin.getImageDescriptor("ovr16/r_inchg_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.RIGHT + Differencer.CHANGE]= CompareUIPlugin.getImageDescriptor("ovr16/r_outchg_ov.gif"); //$NON-NLS-1$
} else {
fgImages[Differencer.ADDITION]= CompareUIPlugin.getImageDescriptor("ovr16/add_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.LEFT + Differencer.ADDITION]= CompareUIPlugin.getImageDescriptor("ovr16/inadd_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.RIGHT + Differencer.ADDITION]= CompareUIPlugin.getImageDescriptor("ovr16/outadd_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.DELETION]= CompareUIPlugin.getImageDescriptor("ovr16/del_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.LEFT + Differencer.DELETION]= CompareUIPlugin.getImageDescriptor("ovr16/indel_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.RIGHT + Differencer.DELETION]= CompareUIPlugin.getImageDescriptor("ovr16/outdel_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.LEFT + Differencer.CHANGE]= CompareUIPlugin.getImageDescriptor("ovr16/inchg_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.RIGHT + Differencer.CHANGE]= CompareUIPlugin.getImageDescriptor("ovr16/outchg_ov.gif"); //$NON-NLS-1$
}
fgImages[Differencer.CONFLICTING + Differencer.ADDITION]= CompareUIPlugin.getImageDescriptor("ovr16/confadd_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.CONFLICTING + Differencer.DELETION]= CompareUIPlugin.getImageDescriptor("ovr16/confdel_ov.gif"); //$NON-NLS-1$
fgImages[Differencer.CONFLICTING + Differencer.CHANGE]= CompareUIPlugin.getImageDescriptor("ovr16/confchg_ov.gif"); //$NON-NLS-1$
}
private IPreferenceStore fPreferenceStore;
private ListenerList fListeners= new ListenerList();
private HashMap fProperties= new HashMap();
private boolean fLeftEditable= true;
private boolean fRightEditable= true;
private String fAncestorLabel;
private String fLeftLabel;
private String fRightLabel;
private Image fAncestorImage;
private Image fRightImage;
private Image fLeftImage;
private ICompareContainer fContainer;
private DefaultLabelProvider labelProvider = new DefaultLabelProvider();
private boolean fDisposed;
private LocalResourceManager fResourceManager;
private Set fIgnoredChanges = new HashSet(6);
private class DefaultLabelProvider extends LabelProvider implements ICompareInputLabelProvider, ILabelProviderListener {
private Map labelProviders = new HashMap();
private ICompareInputLabelProvider defaultLabelProvider;
public Image getAncestorImage(Object input) {
ICompareInputLabelProvider provider = getLabelProvider(input);
if (provider != null) {
Image image = provider.getAncestorImage(input);
if (image != null)
return image;
}
return fAncestorImage;
}
public String getAncestorLabel(Object input) {
ICompareInputLabelProvider provider = getLabelProvider(input);
if (provider != null) {
String label = provider.getAncestorLabel(input);
if (label != null)
return label;
}
return fAncestorLabel;
}
public Image getLeftImage(Object input) {
ICompareInputLabelProvider provider = getLabelProvider(input);
if (provider != null) {
Image image = provider.getLeftImage(input);
if (image != null)
return image;
}
return fLeftImage;
}
public String getLeftLabel(Object input) {
ICompareInputLabelProvider provider = getLabelProvider(input);
if (provider != null) {
String label = provider.getLeftLabel(input);
if (label != null)
return label;
}
return fLeftLabel;
}
public Image getRightImage(Object input) {
ICompareInputLabelProvider provider = getLabelProvider(input);
if (provider != null) {
Image image = provider.getRightImage(input);
if (image != null)
return image;
}
return fRightImage;
}
public String getRightLabel(Object input) {
ICompareInputLabelProvider provider = getLabelProvider(input);
if (provider != null) {
String label = provider.getRightLabel(input);
if (label != null)
return label;
}
return fRightLabel;
}
public ICompareInputLabelProvider getLabelProvider(Object input) {
ICompareInputLabelProvider lp = (ICompareInputLabelProvider)labelProviders.get(input);
if (lp == null)
return defaultLabelProvider;
return lp;
}
public void setLabelProvider(ICompareInput input, ICompareInputLabelProvider labelProvider) {
ICompareInputLabelProvider old = (ICompareInputLabelProvider)labelProviders.get(input);
if (old != null)
old.removeListener(this);
labelProviders.put(input, labelProvider);
labelProvider.addListener(this);
}
public Image getImage(Object element) {
ICompareInputLabelProvider provider = getLabelProvider(element);
if (provider != null) {
Image image = provider.getImage(element);
if (image != null)
return image;
}
if (element instanceof ICompareInput) {
ICompareInput ci = (ICompareInput) element;
Image image = ci.getImage();
if (image != null)
return image;
}
return super.getImage(element);
}
public String getText(Object element) {
ICompareInputLabelProvider provider = getLabelProvider(element);
if (provider != null) {
String label = provider.getText(element);
if (label != null)
return label;
}
if (element instanceof ICompareInput) {
ICompareInput ci = (ICompareInput) element;
String label = ci.getName();
if (label != null)
return label;
}
return super.getText(element);
}
public void dispose() {
for (Iterator iterator = labelProviders.values().iterator(); iterator.hasNext();) {
ICompareInputLabelProvider lp = (ICompareInputLabelProvider) iterator.next();
lp.removeListener(this);
}
if (defaultLabelProvider != null)
defaultLabelProvider.removeListener(this);
defaultLabelProvider = null;
labelProviders.clear();
}
public void labelProviderChanged(LabelProviderChangedEvent event) {
fireLabelProviderChanged(new LabelProviderChangedEvent(this, event.getElements()));
}
public void setDefaultLabelProvider(ICompareInputLabelProvider labelProvider) {
if (defaultLabelProvider != null)
defaultLabelProvider.removeListener(this);
defaultLabelProvider = labelProvider;
if (defaultLabelProvider != null)
defaultLabelProvider.addListener(this);
}
}
/**
* Creates a new configuration with editable left and right sides,
* suitable default labels, and no images.
* The given preference store is used to connect this configuration
* with the Compare preference page properties <code>ComparePreferencePage.INITIALLY_SHOW_ANCESTOR_PANE</code>,
* and <code>CompareConfiguration.IGNORE_WHITESPACE</code>.
*
* @param prefStore the preference store which this configuration holds onto.
* @since 2.0
*/
public CompareConfiguration(IPreferenceStore prefStore) {
setProperty("LEFT_IS_LOCAL", Boolean.valueOf(fLeftIsLocal)); //$NON-NLS-1$
fPreferenceStore= prefStore;
if (fPreferenceStore != null) {
boolean b= fPreferenceStore.getBoolean(ComparePreferencePage.INITIALLY_SHOW_ANCESTOR_PANE);
setProperty(ICompareUIConstants.PROP_ANCESTOR_VISIBLE, new Boolean(b));
b= fPreferenceStore.getBoolean(ComparePreferencePage.IGNORE_WHITESPACE);
setProperty(CompareConfiguration.IGNORE_WHITESPACE, new Boolean(b));
}
}
/**
* Creates a new configuration with editable left and right sides,
* suitable default labels, and no images.
* This configuration uses the preference store of the Compare plug-in
* (<code>CompareUIPlugin.getDefault().getPreferenceStore()</code>).
*/
public CompareConfiguration() {
this(CompareUIPlugin.getDefault().getPreferenceStore());
}
/**
* Returns the preference store of this configuration.
* @return the preference store of this configuration.
* @since 2.0
*/
public IPreferenceStore getPreferenceStore() {
return fPreferenceStore;
}
/**
* Returns an image showing the specified change kind.
* The different kind of changes are defined in the <code>Differencer</code>.
* Newly created images are remembered by this class and
* disposed when the <code>dispose</code> method is called.
*
* @param kind the kind of change as defined in <code>Differencer</code>.
* @return an modification of the base image reflecting the kind of change.
* @see org.eclipse.compare.structuremergeviewer.Differencer
* @since 2.0
*/
public Image getImage(int kind) {
if (fDisposed)
return null;
ImageDescriptor id= fgImages[kind & 15];
ResourceManager rm = getResourceManager();
return rm.createImage(id);
}
private synchronized ResourceManager getResourceManager() {
if (fResourceManager == null) {
fResourceManager = new LocalResourceManager(JFaceResources.getResources());
}
return fResourceManager;
}
/**
* Returns an image showing the specified change kind applied to a
* given base image. The different kind of changes are defined in the <code>Differencer</code>.
* Typically an implementation would build a composite image
* from the given base image and an image representing the change kind.
* Newly created images are remembered by this class and
* disposed when the <code>dispose</code> method is called.
*
* @param base the image which is modified to reflect the kind of change
* @param kind the kind of change as defined in <code>Differencer</code>.
* @return an modification of the base image reflecting the kind of change.
* @see org.eclipse.compare.structuremergeviewer.Differencer
*/
public Image getImage(Image base, int kind) {
if (fDisposed)
return null;
kind &= 15;
ImageDescriptor id = new DiffImageDescriptor(base, fgImages[kind], ICompareUIConstants.COMPARE_IMAGE_WIDTH, !fLeftIsLocal);
ResourceManager rm = getResourceManager();
return rm.createImage(id);
}
/**
* Dispose of this compare configuration.
* This method is called if the compare configuration is no longer used.
* An implementation must dispose of all resources.
*/
public void dispose() {
fDisposed = true;
if (fResourceManager != null) {
fResourceManager.dispose();
}
labelProvider.dispose();
}
/**
* Fires a <code>PropertyChangeEvent</code> to registered listeners.
*
* @param propertyName the name of the property that has changed
* @param oldValue the property's old value
* @param newValue the property's new value
*/
private void fireChange(String propertyName, Object oldValue, Object newValue) {
PropertyChangeEvent event= null;
Object[] listeners= fListeners.getListeners();
if (listeners != null) {
for (int i= 0; i < listeners.length; i++) {
IPropertyChangeListener l= (IPropertyChangeListener) listeners[i];
if (event == null)
event= new PropertyChangeEvent(this, propertyName, oldValue, newValue);
l.propertyChange(event);
}
}
}
/* (non javadoc)
* see IPropertyChangeNotifier.addListener
*/
public void addPropertyChangeListener(IPropertyChangeListener listener) {
fListeners.add(listener);
}
/* (non javadoc)
* see IPropertyChangeNotifier.removeListener
*/
public void removePropertyChangeListener(IPropertyChangeListener listener) {
fListeners.remove(listener);
}
/**
* Sets the property with the given name.
* If the new value differs from the old a <code>PropertyChangeEvent</code>
* is sent to registered listeners.
*
* @param key the name of the property to set
* @param newValue the new value of the property
*/
public void setProperty(String key, Object newValue) {
Object oldValue= fProperties.get(key);
fProperties.put(key, newValue);
if (oldValue == null || !oldValue.equals(newValue))
fireChange(key, oldValue, newValue);
}
/**
* Returns the property with the given name, or <code>null</code>
* if no such property exists.
*
* @param key the name of the property to retrieve
* @return the property with the given name, or <code>null</code> if not found
*/
public Object getProperty(String key) {
return fProperties.get(key);
}
//---- ancestor
/**
* Sets the label to use for the ancestor of compare/merge viewers.
* This label will be used if the element for which a label
* is requested does not have an ancestor or the element does not have
* a registered label provider or the label provider returns <code>null</code>
* as the label.
*
* @param label the new label for the ancestor of compare/merge viewers
*/
public void setAncestorLabel(String label) {
fAncestorLabel= label;
}
/**
* Returns the label for the ancestor side of compare/merge viewers.
* This label is typically shown in the title of the ancestor area in a compare viewer.
*
* @param element the input object of a compare/merge viewer or <code>null</code>
* @return the label for the ancestor side or <code>null</code>
*/
public String getAncestorLabel(Object element) {
return labelProvider.getAncestorLabel(element);
}
/**
* Sets the image to use for the ancestor of compare/merge viewers.
* The CompareConfiguration does not automatically dispose the old image.
* This image will be used if the element for which a image
* is requested does not have an ancestor or the element does not have
* a registered label provider or the label provider returns <code>null</code>
* as the image.
*
* @param image the new image for the ancestor of compare/merge viewers
*/
public void setAncestorImage(Image image) {
fAncestorImage= image;
}
/**
* Returns the image for the ancestor side of compare/merge viewers.
* This image is typically shown in the title of the ancestor area in a compare viewer.
*
* @param element the input object of a compare/merge viewer or <code>null</code>
* @return the image for the ancestor side or <code>null</code>
*/
public Image getAncestorImage(Object element) {
return labelProvider.getAncestorImage(element);
}
//---- left side
/**
* Controls whether the left side of a merge viewer is editable.
*
* @param editable if the value is <code>true</code> left side is editable
*/
public void setLeftEditable(boolean editable) {
fLeftEditable= editable;
}
/**
* Returns whether the left hand side of a merge viewer is editable.
*
* @return <code>true</code> if the left hand side is editable
*/
public boolean isLeftEditable() {
return fLeftEditable;
}
/**
* Sets the label to use for the left side of compare/merge viewers.
* This label will be used if the element for which a label
* is requested does not have a left contributor or the element does not have
* a registered label provider or the label provider returns <code>null</code>
* as the label.
*
* @param label the new label for the left side of compare/merge viewers
*/
public void setLeftLabel(String label) {
fLeftLabel= label;
}
/**
* Returns the label for the left hand side of compare/merge viewers.
* This label is typically shown in the title of the left side of a compare viewer.
*
* @param element the input object of a compare/merge viewer or <code>null</code>
* @return the label for the left hand side or <code>null</code>
*/
public String getLeftLabel(Object element) {
return labelProvider.getLeftLabel(element);
}
/**
* Sets the image to use for the left side of compare/merge viewers.
* The compare configuration does not automatically dispose the old image.
* This image will be used if the element for which a image
* is requested does not have an left contributor or the element does not have
* a registered label provider or the label provider returns <code>null</code>
* as the image.
*
* @param image the new image for the left side of compare/merge viewers
*/
public void setLeftImage(Image image) {
fLeftImage= image;
}
/**
* Returns the image for the left hand side of compare/merge viewers.
* This image is typically shown in the title of the left side of a compare viewer.
*
* @param element the input object of a compare/merge viewer or <code>null</code>
* @return the image for the left hand side or <code>null</code>
*/
public Image getLeftImage(Object element) {
return labelProvider.getLeftImage(element);
}
//---- right side
/**
* Controls whether the right side of a merge viewer is editable.
*
* @param editable if the value is <code>true</code> right side is editable
*/
public void setRightEditable(boolean editable) {
fRightEditable= editable;
}
/**
* Returns whether the right hand side of a merge viewer is editable.
*
* @return <code>true</code> if the right hand side is editable
*/
public boolean isRightEditable() {
return fRightEditable;
}
/**
* Sets the label to use for the right side of compare/merge viewers.
* This label will be used if the element for which a label
* is requested does not have an right contributor or the element does not have
* a registered label provider or the label provider returns <code>null</code>
* as the label.
*
* @param label the new label for the right side of compare/merge viewers
*/
public void setRightLabel(String label) {
fRightLabel= label;
}
/**
* Returns the label for the right hand side of compare/merge viewers.
* This label is typically shown in the title of the right side of a compare viewer.
*
* @param element the input object of a compare/merge viewer or <code>null</code>
* @return the label for the right hand side or <code>null</code>
*/
public String getRightLabel(Object element) {
return labelProvider.getRightLabel(element);
}
/**
* Sets the image to use for the right side of compare/merge viewers.
* The compare configuration does not automatically dispose the old image.
* This image will be used if the element for which a image
* is requested does not have an right contributor or the element does not have
* a registered label provider or the label provider returns <code>null</code>
* as the image.
*
* @param image the new image for the right side of compare/merge viewers
*/
public void setRightImage(Image image) {
fRightImage= image;
}
/**
* Returns the image for the right hand side of compare/merge viewers.
* This image is typically shown in the title of the right side of a compare viewer.
*
* @param element the input object of a compare/merge viewer or <code>null</code>
* @return the image for the right hand side or <code>null</code>
*/
public Image getRightImage(Object element) {
return labelProvider.getRightImage(element);
}
/**
* Return the container of the compare associated with this configuration.
* @return the container of the compare associated with this configuration
* @since 3.3
*/
public ICompareContainer getContainer() {
if (fContainer == null) {
// Create a default container in case one is not provided
fContainer= new CompareContainer();
}
return fContainer;
}
/**
* Set the container of the compare associated with this configuration.
* @param container the container of the compare associated with this configuration.
* @since 3.3
*/
public void setContainer(ICompareContainer container) {
fContainer = container;
}
/**
* Return the label provider that is used to determine the
* text and labels return by this compare configuration.
* @return the label provider that is used to determine the
* text and labels return by this compare configuration
* @see #getAncestorImage(Object)
* @see #getAncestorLabel(Object)
* @see #getLeftImage(Object)
* @see #getLeftLabel(Object)
* @see #getRightImage(Object)
* @see #getRightLabel(Object)
* @since 3.3
*/
public ICompareInputLabelProvider getLabelProvider() {
return labelProvider;
}
/**
* Set the label provider for the given compare input. The compare configuration
* will not dispose of the label provider when the configuration is disposed.
* It is up to the provider of the label provider to ensure that it is
* disposed when it is no longer needed.
* @param input the compare input
* @param labelProvider the label provider for the compare input
* @since 3.3
*/
public void setLabelProvider(ICompareInput input, ICompareInputLabelProvider labelProvider) {
this.labelProvider.setLabelProvider(input, labelProvider);
}
/**
* Set the default label provider for this configuration. The default label
* provider is used when a particular label provider has not been assigned
* using
* {@link #setLabelProvider(ICompareInput, ICompareInputLabelProvider)}.
* The compare configuration will not dispose of the label provider when the
* configuration is disposed. It is up to the provider of the label provider
* to ensure that it is disposed when it is no longer needed.
*
* @param labelProvider the default label provider
* @since 3.3
*/
public void setDefaultLabelProvider(ICompareInputLabelProvider labelProvider) {
this.labelProvider.setDefaultLabelProvider(labelProvider);
}
/**
* Set whether given change kind should be ignored while computing
* differences between documents. Changes specified by this method will be
* excluded from a comparison result.
*
* @param kind
* type of change, possible values are:
* {@link RangeDifference#CHANGE}
* {@link RangeDifference#CONFLICT} {@link RangeDifference#RIGHT}
* {@link RangeDifference#LEFT} {@link RangeDifference#ANCESTOR}
* {@link RangeDifference#ERROR}
* @param ignored
* whether given kind should be included in the ignored set
* @since 3.5
*/
public void setChangeIgnored(int kind, boolean ignored) {
if (ignored) {
fIgnoredChanges.add(new Integer(kind));
} else {
fIgnoredChanges.remove(new Integer(kind));
}
}
/**
* Return if a given change kind is ignored while computing differences
* between documents.
*
* @param kind
* type of change, possible values are:
* {@link RangeDifference#CHANGE}
* {@link RangeDifference#CONFLICT} {@link RangeDifference#RIGHT}
* {@link RangeDifference#LEFT} {@link RangeDifference#ANCESTOR}
* {@link RangeDifference#ERROR}
* @return whether kind of change is ignored
* @since 3.5
*/
public boolean isChangeIgnored(int kind) {
return fIgnoredChanges.contains(new Integer(kind));
}
}