/******************************************************************************
 * Copyright (c) 2005-2007 BEA Systems, Inc.
 * 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:
 *    Konstantin Komissarchik - initial implementation and ongoing maintenance
 *    David Schneider, david.schneider@unisys.com - [142500] WTP properties pages fonts don't follow Eclipse preferences
 ******************************************************************************/

package org.eclipse.wst.common.project.facet.ui.internal;

import static java.lang.Math.max;
import static org.eclipse.wst.common.project.facet.ui.internal.util.GridLayoutUtil.gd;
import static org.eclipse.wst.common.project.facet.ui.internal.util.GridLayoutUtil.gdfill;
import static org.eclipse.wst.common.project.facet.ui.internal.util.GridLayoutUtil.gdhalign;
import static org.eclipse.wst.common.project.facet.ui.internal.util.GridLayoutUtil.gdhfill;
import static org.eclipse.wst.common.project.facet.ui.internal.util.GridLayoutUtil.gdhhint;
import static org.eclipse.wst.common.project.facet.ui.internal.util.GridLayoutUtil.gdhspan;
import static org.eclipse.wst.common.project.facet.ui.internal.util.GridLayoutUtil.gdwhint;
import static org.eclipse.wst.common.project.facet.ui.internal.util.GridLayoutUtil.gl;
import static org.eclipse.wst.common.project.facet.ui.internal.util.SwtUtil.getPreferredWidth;

import java.lang.reflect.Method;
import java.net.URL;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.IAdapterManager;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.resource.CompositeImageDescriptor;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.resource.ImageRegistry;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ComboBoxCellEditor;
import org.eclipse.jface.viewers.ICellModifier;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.ISelectionProvider;
import org.eclipse.jface.viewers.IStructuredContentProvider;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.ITableLabelProvider;
import org.eclipse.jface.viewers.ITreeContentProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerSorter;
import org.eclipse.jface.window.ToolTip;
import org.eclipse.osgi.util.NLS;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.GC;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Combo;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.MenuItem;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.wst.common.project.facet.core.IActionConfig;
import org.eclipse.wst.common.project.facet.core.ICategory;
import org.eclipse.wst.common.project.facet.core.IConstraint;
import org.eclipse.wst.common.project.facet.core.IPreset;
import org.eclipse.wst.common.project.facet.core.IProjectFacet;
import org.eclipse.wst.common.project.facet.core.IProjectFacetVersion;
import org.eclipse.wst.common.project.facet.core.ProjectFacetsManager;
import org.eclipse.wst.common.project.facet.core.IFacetedProject.Action;
import org.eclipse.wst.common.project.facet.core.runtime.IRuntime;
import org.eclipse.wst.common.project.facet.ui.IDecorationsProvider;
import org.eclipse.wst.common.project.facet.ui.IWizardContext;
import org.eclipse.wst.common.project.facet.ui.internal.AbstractDataModel.IDataModelListener;
import org.eclipse.wst.common.project.facet.ui.internal.ChangeTargetedRuntimesDataModel.IRuntimeFilter;
import org.eclipse.wst.common.project.facet.ui.internal.util.BasicToolTip;
import org.eclipse.wst.common.project.facet.ui.internal.util.HeaderToolTip;
import org.osgi.framework.Bundle;

/**
 * @author <a href="mailto:kosta@bea.com">Konstantin Komissarchik</a>
 */

public final class FacetsSelectionPanel

    extends Composite
    implements ISelectionProvider

{
    private static final String FACET_COLUMN = "facet"; //$NON-NLS-1$
    private static final String VERSION_COLUMN = "version"; //$NON-NLS-1$
    private static final String WIDTH = "width"; //$NON-NLS-1$
    private static final String HEIGHT = "height"; //$NON-NLS-1$
    private static final String CW_FACET = "cw.facet"; //$NON-NLS-1$
    private static final String CW_VERSION = "cw.version"; //$NON-NLS-1$
    private static final String SASH1W1 = "sash.1.weight.1"; //$NON-NLS-1$
    private static final String SASH1W2 = "sash.1.weight.2"; //$NON-NLS-1$
    private static final String SASH2W1 = "sash.2.weight.1"; //$NON-NLS-1$
    private static final String SASH2W2 = "sash.2.weight.2"; //$NON-NLS-1$
    
    private static final String IMG_ERROR = "##error##"; //$NON-NLS-1$
    private static final String IMG_WARNING = "##warning##"; //$NON-NLS-1$
    private static final String IMG_DOWN_ARROW = "##down-arrow##"; //$NON-NLS-1$
    
    private final IDialogSettings settings;
    private final Composite topComposite;
    private final SashForm sform1;
    private final SashForm sform2;
    private final Label presetsLabel;
    private final Combo presetsCombo;
    private final Button savePresetButton;
    private final Button deletePresetButton;
    private final CheckboxTreeViewer treeViewer;
    private final Tree tree;
    private final TreeColumn colFacet;
    private final TreeColumn colVersion;
    private final Menu popupMenu;
    private final MenuItem popupMenuConstraints;
    private final ComboBoxCellEditor ceditor;
    private final FixedFacetToolTip fixedFacetToolTip;
    private final TableViewer problemsView;
    private final RuntimesPanel runtimesPanel;
    private final Button showHideRuntimesButton;
    
    private final IWizardContext context;

    /**
     * Contains the <code>TableRowData</code> objects representing all of the
     * facets, regardless whether they are displayed or not.
     */

    private final List<TableRowData> data;
    private final Set<IProjectFacetVersion> base;
    private final Set<Action> actions;
    private Object oldSelection;

    private IStatus problems;
    private final List<Listener> listeners;
    private final List<ISelectionChangedListener> selectionListeners;
    
    private final ModifyFacetedProjectDataModel model;
    
    /**
     * Holds images used throughout the panel.
     */
    
    private final ImageRegistry imageRegistry;
    
    public interface IFilter 
    {
        boolean check( IProjectFacetVersion fv );
    }

    public FacetsSelectionPanel( final Composite parent,
                                 final int style,
                                 final IWizardContext context,
                                 final Set<IProjectFacetVersion> base,
                                 final ModifyFacetedProjectDataModel model )
    {
        super( parent, style );

        this.context = context;
        this.data = new ArrayList<TableRowData>();
        this.model = model;
        this.base = ( base == null ? new HashSet<IProjectFacetVersion>() : base );
        this.actions = new HashSet<Action>();
        this.oldSelection = null;
        this.problems = Status.OK_STATUS;
        this.listeners = new ArrayList<Listener>();
        this.selectionListeners = new ArrayList<ISelectionChangedListener>();
        
        for( IProjectFacet f : ProjectFacetsManager.getProjectFacets() )
        {
            try
            {
                this.data.add( new TableRowData( f ) );
            }
            catch( CoreException e )
            {
                FacetUiPlugin.log( e );
            }
        }
        
        // Initialize the image registry.
        
        this.imageRegistry = new ImageRegistry();
        final Bundle bundle = Platform.getBundle( FacetUiPlugin.PLUGIN_ID );
        
        URL url = bundle.getEntry( "images/error.gif" ); //$NON-NLS-1$
        this.imageRegistry.put( IMG_ERROR, ImageDescriptor.createFromURL( url ) );

        url = bundle.getEntry( "images/warning.gif" ); //$NON-NLS-1$
        this.imageRegistry.put( IMG_WARNING, ImageDescriptor.createFromURL( url ) );

        url = bundle.getEntry( "images/down-arrow.gif" ); //$NON-NLS-1$
        this.imageRegistry.put( IMG_DOWN_ARROW, ImageDescriptor.createFromURL( url ) );

        // Read the dialog settings.

        final IDialogSettings root
            = FacetUiPlugin.getInstance().getDialogSettings();

        IDialogSettings temp = root.getSection( getClass().getName() );

        if( temp == null )
        {
            temp = root.addNewSection( getClass().getName() );
        }
        
        if( temp.get( WIDTH ) == null ) temp.put( WIDTH, 600 );
        if( temp.get( HEIGHT ) == null ) temp.put( HEIGHT, 300 );
        if( temp.get( SASH1W1 ) == null ) temp.put( SASH1W1, 60 );
        if( temp.get( SASH1W2 ) == null ) temp.put( SASH1W2, 40 );
        if( temp.get( SASH2W1 ) == null ) temp.put( SASH2W1, 70 );
        if( temp.get( SASH2W2 ) == null ) temp.put( SASH2W2, 30 );
        
        this.settings = temp;

        // Layout the panel.

        final GridLayout layout = new GridLayout( 1, false );
        layout.marginWidth = 0;
        layout.marginHeight = 0;
        
        setLayout( layout );
        
        final GridData topgd = gdfill();
        topgd.heightHint = this.settings.getInt( HEIGHT );
        topgd.widthHint = this.settings.getInt( WIDTH );
        
        this.topComposite = new Composite( this, SWT.NONE );
        this.topComposite.setLayout( new GridLayout( 4, false ) );
        this.topComposite.setLayoutData( topgd );
        
        this.topComposite.addListener
        (
            SWT.Resize,
            new Listener()
            {
                public void handleEvent( final Event event )
                {
                    final Point size 
                        = FacetsSelectionPanel.this.topComposite.getSize();
                    
                    FacetsSelectionPanel.this.settings.put( WIDTH, size.x );
                    FacetsSelectionPanel.this.settings.put( HEIGHT, size.y );
                }
            }
        );

        this.presetsLabel = new Label( this.topComposite, SWT.NONE );
        this.presetsLabel.setText( Resources.presetsLabel );
        
        this.presetsCombo = new Combo( this.topComposite, SWT.READ_ONLY );
        this.presetsCombo.setLayoutData( gdhfill() );
        
        syncWithPresetsModel( this.presetsCombo );
        
        this.savePresetButton = new Button( this.topComposite, SWT.PUSH );
        this.savePresetButton.setText( Resources.saveButtonLabel );
        
        this.savePresetButton.addSelectionListener
        (
            new SelectionAdapter()
            {
                public void widgetSelected( final SelectionEvent e )
                {
                    handleSavePreset();
                }
            }
        );

        this.deletePresetButton = new Button( this.topComposite, SWT.PUSH );
        this.deletePresetButton.setText( Resources.deleteButtonLabel );
        
        this.deletePresetButton.addSelectionListener
        (
            new SelectionAdapter()
            {
                public void widgetSelected( final SelectionEvent e )
                {
                    handleDeletePreset();
                }
            }
        );
        
        final int width 
            = Math.max( getPreferredWidth( this.savePresetButton ), 
                        getPreferredWidth( this.deletePresetButton ) ) + 15;
                        
        this.savePresetButton.setLayoutData( gdwhint( gd(), width ) );
        this.deletePresetButton.setLayoutData( gdwhint( gd(), width ) );
        
        this.sform1 = new SashForm( this.topComposite, SWT.HORIZONTAL | SWT.SMOOTH );
        this.sform1.setLayoutData( gdhspan( gdfill(), 4 ) );
        
        this.sform2 = new SashForm( this.sform1, SWT.VERTICAL | SWT.SMOOTH );
        this.sform2.setLayoutData( gdhspan( gdfill(), 4 ) );
        
        this.treeViewer = new CheckboxTreeViewer( this.sform2, SWT.BORDER );
        this.tree = this.treeViewer.getTree();
        
        this.tree.setHeaderVisible( true );

        this.ceditor = new ComboBoxCellEditor( this.tree, new String[ 0 ], SWT.READ_ONLY );

        this.treeViewer.setColumnProperties( new String[] { FACET_COLUMN, VERSION_COLUMN } );
        this.treeViewer.setCellModifier( new CellModifier() );
        this.treeViewer.setCellEditors( new CellEditor[] { null, this.ceditor } );

        this.treeViewer.setContentProvider( new ContentProvider() );
        this.treeViewer.setLabelProvider( new LabelProvider() );
        this.treeViewer.setSorter( new Sorter() );
        
        this.colFacet = new TreeColumn( this.tree, SWT.NONE );
        this.colFacet.setText( Resources.facetColumnLabel );
        this.colFacet.setResizable( true );
        
        if( this.settings.get( CW_FACET ) == null )
        {
            this.settings.put( CW_FACET, computeDefaultFacetColumnWidth() );
        }
        
        this.colFacet.setWidth( this.settings.getInt( CW_FACET ) );
        
        this.colFacet.addListener
        (
            SWT.Resize,
            new Listener()
            {
                public void handleEvent( final Event event )
                {
                    FacetsSelectionPanel.this.settings.put( CW_FACET, FacetsSelectionPanel.this.colFacet.getWidth() );
                }
            }
        );

        this.colVersion = new TreeColumn( this.tree, SWT.NONE );
        this.colVersion.setText( Resources.versionColumnLabel );
        this.colVersion.setResizable( true );
        
        if( this.settings.get( CW_VERSION ) == null )
        {
            this.settings.put( CW_VERSION, computeDefaultVersionColumnWidth() );
        }

        this.colVersion.setWidth( this.settings.getInt( CW_VERSION ) );
        
        this.colVersion.addListener
        (
            SWT.Resize,
            new Listener()
            {
                public void handleEvent( final Event event )
                {
                    FacetsSelectionPanel.this.settings.put( CW_VERSION, FacetsSelectionPanel.this.colVersion.getWidth() );
                }
            }
        );

        this.popupMenu = new Menu( getShell(), SWT.POP_UP );
        this.popupMenuConstraints = new MenuItem( this.popupMenu, SWT.PUSH );
        this.popupMenuConstraints.setText( Resources.showConstraints );
        
        this.popupMenuConstraints.addSelectionListener
        (
            new SelectionAdapter()
            {
                public void widgetSelected( SelectionEvent e )
                {
                    handleShowConstraints();
                }
            }
        );
        
        new FacetToolTip( this.tree );
        new CategoryToolTip( this.tree );
        this.fixedFacetToolTip = new FixedFacetToolTip( this.tree );
        
        this.treeViewer.setInput( new Object() );

        this.treeViewer.addSelectionChangedListener
        (
            new ISelectionChangedListener()
            {
                public void selectionChanged( final SelectionChangedEvent e )
                {
                    FacetsSelectionPanel.this.selectionChanged( e );
                }
            }
        );

        this.treeViewer.addCheckStateListener
        (
            new ICheckStateListener()
            {
                public void checkStateChanged( final CheckStateChangedEvent e )
                {
                    FacetsSelectionPanel.this.checkStateChanged( e );
                }
            }
        );

        this.tree.addListener
        (
            SWT.MouseDown,
            new Listener()
            {
                public void handleEvent( final Event event )
                {
                    handleMouseDownEvent( event );
                }
            }
        );
        
        this.tree.addListener
        (
            SWT.PaintItem,
            new Listener()
            {
                public void handleEvent( final Event event )
                {
                    handlePaintItemEvent( event );
                }
            }
        );
        
        this.problemsView = new TableViewer( this.sform2, SWT.BORDER );
        this.problemsView.setContentProvider( new ProblemsContentProvider() );
        this.problemsView.setLabelProvider( new ProblemsLabelProvider() );
        this.problemsView.setInput( new Object() );

        this.problemsView.getTable().addListener
        (
            SWT.Resize,
            new Listener()
            {
                public void handleEvent( final Event event )
                {
                    final int[] weights = FacetsSelectionPanel.this.sform2.getWeights();
                    FacetsSelectionPanel.this.settings.put( SASH2W1, weights[ 0 ] );
                    FacetsSelectionPanel.this.settings.put( SASH2W2, weights[ 1 ] );
                }
            }
        );

        final int[] weights2
            = new int[] { this.settings.getInt( SASH2W1 ),
                          this.settings.getInt( SASH2W2 ) };

        this.sform2.setWeights( weights2 );
        
        this.runtimesPanel 
            = new RuntimesPanel( this.sform1, SWT.NONE, 
                                 this.model.getTargetedRuntimesDataModel() );
        
        this.runtimesPanel.setLayoutData( gdhhint( gdhfill(), 80 ) );
        
        this.model.getTargetedRuntimesDataModel().addRuntimeFilter
        ( 
            new IRuntimeFilter()
            {
                public boolean check( final IRuntime runtime )
                {
                    for( IProjectFacetVersion fv : getSelectedProjectFacets() )
                    {
                        if( ! runtime.supports( fv ) )
                        {
                            return false;
                        }
                    }
                    
                    return true;
                }
            }
        );
        
        addProjectFacetsListener
        (
            new Listener()
            {
                public void handleEvent( final Event event )
                {
                    final ChangeTargetedRuntimesDataModel rdm
                        = getDataModel().getTargetedRuntimesDataModel();
                    
                    rdm.refreshTargetableRuntimes();
                }
            }
        );
        
        this.runtimesPanel.addListener
        (
            SWT.Resize,
            new Listener()
            {
                public void handleEvent( final Event event )
                {
                    final int[] weights = FacetsSelectionPanel.this.sform1.getWeights();
                    FacetsSelectionPanel.this.settings.put( SASH1W1, weights[ 0 ] );
                    FacetsSelectionPanel.this.settings.put( SASH1W2, weights[ 1 ] );
                }
            }
        );

        final int[] weights1
            = new int[] { this.settings.getInt( SASH1W1 ),
                          this.settings.getInt( SASH1W2 ) };
    
        this.sform1.setWeights( weights1 );
        this.sform1.setMaximizedControl( this.sform2 );
        
        this.showHideRuntimesButton = new Button( this.topComposite, SWT.PUSH );
        this.showHideRuntimesButton.setText( Resources.showRuntimes );
        GridData gd = gdhalign( gdhspan( gd(), 4 ), GridData.END );
        gd = gdwhint( gd, getPreferredWidth( this.showHideRuntimesButton ) + 15 );
        this.showHideRuntimesButton.setLayoutData( gd );
        
        this.showHideRuntimesButton.addSelectionListener
        (
            new SelectionAdapter()
            {
                public void widgetSelected( final SelectionEvent e )
                {
                    handleShowHideRuntimes();
                }
            }
        );
        
        this.addDisposeListener
        (
            new DisposeListener()
            {
                public void widgetDisposed( final DisposeEvent e )
                {
                    handleDisposeEvent();
                }
            }
        );
        
        updateValidationDisplay();
        Dialog.applyDialogFont(parent);
        
        // Bind to the model.
        
        this.model.addListener
        ( 
            ModifyFacetedProjectDataModel.EVENT_FIXED_FACETS_CHANGED, 
            new IDataModelListener()
            {
                public void handleEvent()
                {
                    handleModelChangedEvent( ModifyFacetedProjectDataModel.EVENT_FIXED_FACETS_CHANGED );
                }
            }
        );

        this.model.addListener
        ( 
            ModifyFacetedProjectDataModel.EVENT_SELECTED_PRESET_CHANGED, 
            new IDataModelListener()
            {
                public void handleEvent()
                {
                    handleModelChangedEvent( ModifyFacetedProjectDataModel.EVENT_SELECTED_PRESET_CHANGED );
                }
            }
        );
        
        syncWithPresetsModel( this.presetsCombo );
        
        this.model.getTargetedRuntimesDataModel().addListener
        ( 
            ChangeTargetedRuntimesDataModel.EVENT_TARGETED_RUNTIMES_CHANGED,
            new IDataModelListener()
            {
                public void handleEvent()
                {
                    handleModelChangedEvent( ChangeTargetedRuntimesDataModel.EVENT_TARGETED_RUNTIMES_CHANGED );
                }
            }
        );
    }
    
    public ModifyFacetedProjectDataModel getDataModel()
    {
        return this.model;
    }
    
    public boolean isSelectionValid()
    {
        return ( this.problems.getSeverity() != IStatus.ERROR );
    }
    
    public Set<Action> getActions()
    {
        return this.actions;
    }
    
    public Action getAction( final Action.Type type,
                             final IProjectFacetVersion f )
    {
        return getAction( this.actions, type, f );
    }
    
    private static Action getAction( final Set<Action> actions,
                                     final Action.Type type,
                                     final IProjectFacetVersion fv )
    {
        for( Action action : actions )
        {
            if( action.getType() == type && action.getProjectFacetVersion() == fv )
            {
                return action;
            }
        }
        
        return null;
    }
    
    private static Action getAction( final Set<Action> actions,
                                     final Action.Type type,
                                     final IProjectFacet f )
    {
        for( Action action : actions )
        {
            if( action.getType() == type && 
                action.getProjectFacetVersion().getProjectFacet() == f )
            {
                return action;
            }
        }
        
        return null;
    }
    
    private Action createAction( final Set<Action> actions,
                                 final Action.Type type,
                                 final IProjectFacetVersion fv )
    {
        Action action = getAction( actions, type, fv );
        
        if( action == null )
        {
            Object config = null;
            
            if( fv.supports( this.base, type ) )
            {
                try
                {
                    final IProjectFacet f = fv.getProjectFacet();
                    
                    action = getAction( actions, type, f );
                    
                    if( action != null )
                    {
                        final IProjectFacetVersion current
                            = action.getProjectFacetVersion();
                        
                        if( fv.supports( this.base, type ) &&
                            current.supports( this.base, type ) &&
                            fv.getActionDefinition( this.base, type )
                              == current.getActionDefinition( this.base, type ) )
                        {
                            config = action.getConfig();
                            
                            IActionConfig c = null;
                            
                            if( config instanceof IActionConfig )
                            {
                                c = (IActionConfig) config;
                            }
                            else if( config != null )
                            {
                                final IAdapterManager m 
                                    = Platform.getAdapterManager();
                                
                                final String t
                                    = IActionConfig.class.getName();
                                
                                c = (IActionConfig) m.loadAdapter( config, t );
                            }
                            
                            if( c != null )
                            {
                                c.setVersion( fv );
                            }
                        }
                    }
                    
                    if( config == null )
                    {
                    	final String pjname = this.context.getProjectName();
                        config = this.context.getConfig(fv, type, pjname);
                    }
                }
                catch( CoreException e )
                {
                    FacetUiPlugin.log( e );
                }
            }

            action = new Action( type, fv, config );
        }
        
        return action;
    }
    
    public void setDefaultFacetsForRuntime( final IRuntime runtime )
    {
        final Set<IProjectFacetVersion> defaultFacets;
        
        if( runtime != null )
        {
            try
            {
                defaultFacets = runtime.getDefaultFacets( this.model.getFixedFacets() );
            }
            catch( CoreException e )
            {
                FacetUiPlugin.log( e );
                return;
            }
        }
        else
        {
            defaultFacets = new HashSet<IProjectFacetVersion>();
            
            for( IProjectFacet f : this.model.getFixedFacets() )
            {
                defaultFacets.add( f.getDefaultVersion() );
            }
        }
            
        setSelectedProjectFacets( defaultFacets );
        this.model.setSelectedPreset( null );
    }
    
    public Set<IProjectFacetVersion> getSelectedProjectFacets()
    {
        final Set<IProjectFacetVersion> set = new HashSet<IProjectFacetVersion>();

        for( TableRowData trd : this.data )
        {
            if( trd.isSelected() )
            {
                set.add( trd.getCurrentVersion() );
            }
        }

        return set;
    }

    public void setSelectedProjectFacets( final Set<IProjectFacetVersion> sel )
    {
        final List<TableRowData> toCheck = new ArrayList<TableRowData>();
        final List<TableRowData> needsCategoryRefresh = new ArrayList<TableRowData>();
        
        for( IProjectFacetVersion fv : sel )
        {
            final IProjectFacet f = fv.getProjectFacet();
            final TableRowData trd = findTableRowData( f, true );

            if( fv.getPluginId() == null )
            {
                trd.addUnknownVersion( fv );
            }
            
            trd.setSelected( true );
            trd.setCurrentVersion( fv );
            
            toCheck.add( trd );
            needsCategoryRefresh.add( trd );
        }

        for( TableRowData trd : this.data )
        {
            if( trd.isSelected() && ! sel.contains( trd.getCurrentVersion() ) )
            {
                trd.setSelected( false );
                needsCategoryRefresh.add( trd );
            }
        }

        refresh();
        
        this.treeViewer.setCheckedElements( toCheck.toArray() );
        
        for( TableRowData trd : needsCategoryRefresh )
        {
            refreshCategoryState( trd );
        }
        
        updateValidationDisplay();
    }
    
    public void setFixedProjectFacets( final Set<IProjectFacet> fixed )
    {
        this.model.setFixedFacets( fixed );
    }
    
    /**
     * @deprecated
     */
    
    public void selectPreset( final IPreset preset )
    {
        this.model.setSelectedPreset( preset.getId() );
    }
    
    public boolean setFocus()
    {
        return this.tree.setFocus();
    }
    
    public void addProjectFacetsListener( final Listener listener )
    {
        this.listeners.add( listener );
    }

    public void removeProjectFacetsListener( final Listener listener )
    {
        this.listeners.remove( listener );
    }

    private void notifyProjectFacetsListeners()
    {
        for( Listener listener : this.listeners )
        {
            listener.handleEvent( null );
        }
    }
    
    public void addSelectionChangedListener( final ISelectionChangedListener listener )
    {
        this.selectionListeners.add( listener );
    }

    public void removeSelectionChangedListener( final ISelectionChangedListener listener )
    {
        this.selectionListeners.remove( listener );
    }

    public ISelection getSelection()
    {
        final IStructuredSelection ss
            = (IStructuredSelection) this.treeViewer.getSelection();

        Object sel = ss.getFirstElement();

        if( sel instanceof TableRowData )
        {
            sel = ( (TableRowData) sel ).getProjectFacet();
        }

        if( sel == null )
        {
            return new StructuredSelection( new Object[ 0 ] );
        }
        else
        {
            return new StructuredSelection( sel );
        }
    }

    public void setSelection( final ISelection selection )
    {
        final IStructuredSelection ss = (IStructuredSelection) selection;
        final Object sel = ss.getFirstElement();
        final ISelection ts;

        if( sel == null )
        {
            ts = new StructuredSelection( new Object[ 0 ] );
        }
        else
        {
            if( sel instanceof IProjectFacet )
            {
                final TableRowData trd
                    = findTableRowData( (IProjectFacet) sel );

                ts = new StructuredSelection( trd );
            }
            else
            {
                ts = selection;
            }
        }

        this.treeViewer.setSelection( ts );
    }

    public void notifySelectionChangedListeners()
    {
        final SelectionChangedEvent event = new SelectionChangedEvent( this, getSelection() );

        for( ISelectionChangedListener listener : this.selectionListeners )
        {
            listener.selectionChanged( event );
        }
    }
    
    private ImageRegistry getImageRegistry()
    {
        return this.imageRegistry;
    }

    private void selectionChanged( final SelectionChangedEvent event )
    {
        final Object selection
            = ( (IStructuredSelection) event.getSelection() ).getFirstElement();

        if( selection != this.oldSelection )
        {
            this.oldSelection = selection;
            refreshVersionsDropDown();
            notifySelectionChangedListeners();
        }
    }
    
    private void checkStateChanged( final CheckStateChangedEvent event )
    {
        final Object el = event.getElement();
        final boolean checked = event.getChecked();

        if( el instanceof TableRowData )
        {
            final TableRowData trd = (TableRowData) el;
            
            if( trd.isFixed() )
            {
                if( ! checked )
                {
                    this.treeViewer.setChecked( el, true );
                    
                    final String msg 
                        = NLS.bind( Resources.couldNotDeselectFixedFacetMessage,
                                    trd.getProjectFacet().getLabel() );                    

                    this.fixedFacetToolTip.setMessage( msg );
                    
                    final Point cursorLocation = getDisplay().getCursorLocation();
                    this.fixedFacetToolTip.show( this.tree.toControl( cursorLocation ) );
                }
                
                return;
            }
            
            trd.setSelected( checked );
            refreshCategoryState( trd );
        }
        else
        {
            final ContentProvider cp
                = (ContentProvider) this.treeViewer.getContentProvider();

            final Object[] children = cp.getChildren( el );
            int selected = 0;
            
            for( Object child : children )
            {
                final TableRowData trd = (TableRowData) child;
                
                if( ! trd.isFixed() )
                {
                    trd.setSelected( checked );
                    this.treeViewer.setChecked( trd, checked );
                }
                
                if( trd.isSelected() )
                {
                    selected++;
                }
            }
            
            if( selected == 0 || selected == children.length )
            {
                this.treeViewer.setGrayed( el, false );
            }
            else
            {
                this.treeViewer.setGrayChecked( el, true );
            }
        }

        updateValidationDisplay();
        
        this.model.setSelectedPreset( null );
    }

    private void updateValidationDisplay()
    {
        final Set<IProjectFacetVersion> sel = getSelectedProjectFacets();
        final Set<Action> old = new HashSet<Action>( this.actions );
        this.actions.clear();
        
        // What has been removed?
        
        for( IProjectFacetVersion fv : this.base )
        {
            if( ! sel.contains( fv ) )
            {
                this.actions.add( createAction( old, Action.Type.UNINSTALL, fv ) );
            }
        }

        // What has been added?

        for( IProjectFacetVersion fv : sel )
        {
            if( ! this.base.contains( fv ) )
            {
                this.actions.add( createAction( old, Action.Type.INSTALL, fv ) );
            }
        }
        
        // Coalesce uninstall/install pairs into version change actions, if
        // possible.
        
        final Set<Action> toadd = new HashSet<Action>();
        final Set<Action> toremove = new HashSet<Action>();
        
        for( Action action1 : this.actions )
        {
            for( Action action2 : this.actions )
            {
                if( action1.getType() == Action.Type.UNINSTALL &&
                    action2.getType() == Action.Type.INSTALL )
                {
                    final IProjectFacetVersion f1 = action1.getProjectFacetVersion();
                    final IProjectFacetVersion f2 = action2.getProjectFacetVersion();
                    
                    if( f1.getProjectFacet() == f2.getProjectFacet() )
                    {
                        toremove.add( action1 );
                        toremove.add( action2 );
                        toadd.add( createAction( old, Action.Type.VERSION_CHANGE, f2 ) );
                    }
                }
            }
        }
        
        this.actions.removeAll( toremove );
        this.actions.addAll( toadd );
        
        this.problems = calculateProblems();
        this.problemsView.refresh();

        if( this.problems.isOK() )
        {
            if( this.sform2.getMaximizedControl() == null )
            {
                this.sform2.setMaximizedControl( this.tree );
            }
        }
        else
        {
            if( this.sform2.getMaximizedControl() != null )
            {
                this.sform2.setMaximizedControl( null );
            }
        }

        notifyProjectFacetsListeners();
    }
    
    private IStatus calculateProblems()
    {
        IStatus st = ProjectFacetsManager.check( this.base, this.actions );
        
        for( IProjectFacetVersion fv : this.base )
        {
            final IProjectFacet f = fv.getProjectFacet();
            
            String msg = null; 
            
            if( f.getPluginId() == null )
            {
                msg = NLS.bind( Resources.facetNotFound, f.getId() );
            }
            else if( fv.getPluginId() == null )
            {
                msg = NLS.bind( Resources.facetVersionNotFound, f.getId(), 
                                fv.getVersionString() );
            }
            
            if( msg != null )
            {
                final IStatus sub
                    = new Status( IStatus.WARNING, FacetUiPlugin.PLUGIN_ID, 0,
                                  msg, null );
                
                final IStatus[] existing = st.getChildren();
                final IStatus[] modified = new IStatus[ existing.length + 1 ];
                System.arraycopy( existing, 0, modified, 0, existing.length );
                modified[ existing.length ] = sub;
                
                st = new MultiStatus( FacetUiPlugin.PLUGIN_ID, 0, modified, 
                                      "", null ); //$NON-NLS-1$
            }
        }
        
        return st;
    }
    
    private void refresh()
    {
        // Somehow the checked state of nested items gets lost when a refresh
        // is performed, so we have to do this workaround.
        
        final Object[] checked = this.treeViewer.getCheckedElements();
        this.treeViewer.refresh();
        this.treeViewer.setCheckedElements( checked );
        refreshVersionsDropDown();
    }
    
    public void setCategoryExpandedState( final ICategory category,
                                          final boolean expanded )
    {
        this.treeViewer.setExpandedState( category, expanded );
    }
    
    public void syncWithPresetsModel( final Combo combo )
    {
        final List<IPreset> sortedPresets = new ArrayList<IPreset>();
        
        // Contents : model -> view

        final IDataModelListener modelToViewContentsListener = new IDataModelListener()
        {
            public void handleEvent()
            {
                synchronized( sortedPresets )
                {
                    sortedPresets.clear();
                    sortedPresets.addAll( FacetsSelectionPanel.this.model.getAvailablePresets() );
                    
                    Collections.sort
                    (
                        sortedPresets,
                        new Comparator<IPreset>()
                        {
                            public int compare( final IPreset p1, 
                                                final IPreset p2 ) 
                            {
                                if( p1 == p2 )
                                {
                                    return 0;
                                }
                                else
                                {
                                    return p1.getLabel().compareTo( p2.getLabel() );
                                }
                            }
                        }
                    );
                    
                    final IPreset selectedPreset 
                        = FacetsSelectionPanel.this.model.getSelectedPreset();
                    
                    combo.removeAll();
                    combo.add( Resources.customPreset );
                    
                    if( selectedPreset == null )
                    {
                        combo.select( 0 );
                    }
                    
                    for( IPreset preset : sortedPresets )
                    {
                        combo.add( preset.getLabel() );
                        
                        if( preset == selectedPreset )
                        {
                            combo.select( combo.getItemCount() - 1 );
                        }
                    }
                }
            }
        };

        this.model.addListener( ModifyFacetedProjectDataModel.EVENT_AVAILABLE_PRESETS_CHANGED,
                                modelToViewContentsListener );
        
        // Selection : model -> view
        
        this.model.addListener
        ( 
            ModifyFacetedProjectDataModel.EVENT_SELECTED_PRESET_CHANGED, 
            new IDataModelListener()
            {
                public void handleEvent()
                {
                    synchronized( sortedPresets )
                    {
                        final IPreset preset
                            = FacetsSelectionPanel.this.model.getSelectedPreset();
                        
                        final int index;
                        
                        if( preset == null )
                        {
                            index = -1;
                        }
                        else
                        {
                            index = sortedPresets.indexOf( preset );
                        }
                        
                        combo.select( index + 1 );
                        
                        handlePresetSelected();
                    }
                }
            }
        );
        
        // Selection : view -> model
        
        combo.addSelectionListener
        (
            new SelectionAdapter()
            {
                public void widgetSelected( final SelectionEvent e )
                {
                    synchronized( sortedPresets )
                    {
                        final int selection = combo.getSelectionIndex();
                        final String presetId;
                        
                        if( selection == 0 )
                        {
                            presetId = null;
                        }
                        else
                        {
                            presetId = sortedPresets.get( selection - 1 ).getId();
                        }
                        
                        FacetsSelectionPanel.this.model.setSelectedPreset( presetId );
                    }
                }
            }
        );
        
        // Trigger initial UI population.
        
        modelToViewContentsListener.handleEvent();
    }
    
    private void refreshCategoryState( final TableRowData trd )
    {
        final ICategory category = trd.getProjectFacet().getCategory();
        
        if( category != null )
        {
            int selected = 0;
    
            for( IProjectFacet f : category.getProjectFacets() )
            {
                final TableRowData ctrd = findTableRowData( f );
    
                if( ctrd.isSelected() )
                {
                    selected++;
                }
            }
    
            if( selected == 0 )
            {
                this.treeViewer.setChecked( category, false );
                this.treeViewer.setGrayed( category, false );
            }
            else if( selected == category.getProjectFacets().size() )
            {
                this.treeViewer.setChecked( category, true );
                this.treeViewer.setGrayed( category, false );
            }
            else
            {
                this.treeViewer.setGrayChecked( category, true );
            }
        }
    }
    
    private void refreshVersionsDropDown()
    {
        final TableRowData trd = getSelectedTableRowData();
        
        if( trd == null )
        {
            return;
        }
        
        final List<IProjectFacetVersion> versions = trd.getVersions();
        final String[] verstrs = new String[ versions.size() ];

        for( int i = 0, n = versions.size(); i < n; i++ )
        {
            final IProjectFacetVersion fv = versions.get( i );
            verstrs[ i ] = fv.getVersionString(); 
        }

        this.ceditor.setItems( verstrs );

        for( int i = 0, n = versions.size(); i < n; i++ )
        {
            if( versions.get( i ) == trd.getCurrentVersion() )
            {
                this.ceditor.setValue( new Integer( i ) );
                break;
            }
        }
    }

    private TableRowData getSelectedTableRowData()
    {
        final IStructuredSelection ssel 
            = (IStructuredSelection) this.treeViewer.getSelection();
        
        if( ssel != null && ! ssel.isEmpty() )
        {
            final Object obj = ssel.getFirstElement();
            
            if( obj instanceof TableRowData )
            {
                return (TableRowData) obj;
            }
        }

        return null;
    }
    
    private TableRowData findTableRowData( final IProjectFacet f )
    {
        return findTableRowData( f, false );
    }

    private TableRowData findTableRowData( final IProjectFacet f,
                                           final boolean createIfNecessary )
    {
        for( TableRowData trd : this.data )
        {
            if( trd.getProjectFacet() == f )
            {
                return trd;
            }
        }
        
        if( createIfNecessary )
        {
            try
            {
                final TableRowData trd = new TableRowData( f );
                this.data.add( trd );
                return trd;
            }
            catch( CoreException e )
            {
                FacetUiPlugin.log( e );
            }
        }

        throw new IllegalStateException();
    }

    private void handleMouseDownEvent( final Event event )
    {
        final List<TreeItem> items = getAllTreeItems();
        
        TreeItem onItem = null;

        for( TreeItem item : items )
        {
            if( item.getBounds( 0 ).contains( event.x, event.y ) )
            {
                onItem = item;
                break;
            }

            if( item.getBounds( 1 ).contains( event.x, event.y ) )
            {
                this.tree.setSelection( new TreeItem[] { item } );
                this.treeViewer.editElement( item.getData(), 1 );
                break;
            }
        }
        
        if( onItem != null && onItem.getData() instanceof TableRowData )
        {
            final TableRowData trd = (TableRowData) onItem.getData();
            final IProjectFacetVersion fv = trd.getCurrentVersion();
            final IConstraint c = fv.getConstraint();
            
            if( c.getType() == IConstraint.Type.AND && 
                c.getOperands().size() == 0 )
            {
                this.popupMenuConstraints.setEnabled( false );
            }
            else
            {
                this.popupMenuConstraints.setEnabled( true );
            }
            
            this.tree.setMenu( this.popupMenu );
        }
        else
        {
            this.tree.setMenu( null );
        }
    }
    
    private void handlePaintItemEvent( final Event event )
    {
        final TreeItem item = (TreeItem) event.item;
        final Object itemData = item.getData();

        if( itemData instanceof TableRowData && event.index == 1 )
        {
            final TableRowData trd = (TableRowData) itemData;
            
            if( trd.getVersions().size() > 1 )
            {
                final Image arrowImage = getImageRegistry().get( IMG_DOWN_ARROW );
                final Rectangle arrowImageBounds = arrowImage.getBounds();
                
                final int columnWidth = this.colVersion.getWidth();
                final int itemHeight = this.tree.getItemHeight();
                
                int x, y;
                
                x = event.x + columnWidth - arrowImageBounds.width - 10;
                y = event.y;
                event.gc.setBackground( item.getDisplay().getSystemColor( SWT.COLOR_WHITE ) );
                event.gc.fillRectangle( x, y, arrowImageBounds.width + 10, itemHeight );
                
                y = event.y + ( itemHeight - arrowImageBounds.height ) / 2;
                event.gc.drawImage( arrowImage, x, y );
            }
        }
    }
    
    private void handleDisposeEvent()
    {
        this.imageRegistry.dispose();
    }
    
    private void handleShowConstraints()
    {
        final TreeItem[] items = this.tree.getSelection();
        if( items.length != 1 ) throw new IllegalStateException();
        final TreeItem item = items[ 0 ];
        final TableRowData trd = (TableRowData) item.getData();
        final IProjectFacetVersion fv = trd.getCurrentVersion();
        
        final Rectangle bounds = item.getBounds();
        
        Point location = new Point( bounds.x, bounds.y + bounds.height );
        location = this.tree.toDisplay( location );
        
        final ConstraintDisplayDialog dialog 
            = new ConstraintDisplayDialog( getShell(), location,
                                           fv.getConstraint() );

        dialog.open();
    }
    
    private void handlePresetSelected()
    {
        final IPreset preset = this.model.getSelectedPreset();
        
        if( preset != null )
        {
            final Set<TableRowData> selected = new HashSet<TableRowData>();
            
            for( IProjectFacetVersion fv : preset.getProjectFacets() )
            {
                final TableRowData trd = findTableRowData( fv.getProjectFacet() );
                
                if( ! trd.isSelected() )
                {
                    this.treeViewer.setChecked( trd, true );
                    trd.setSelected( true );
                    refreshCategoryState( trd );
                }
                
                if( trd.getCurrentVersion() != fv )
                {
                    trd.setCurrentVersion( fv );
                    this.treeViewer.update( trd, null );
                }
                
                selected.add( trd );
            }

            for( TableRowData trd : this.data )
            {
                if( ! selected.contains( trd ) )
                {
                    this.treeViewer.setChecked( trd, false );
                    trd.setSelected( false );
                    refreshCategoryState( trd );
                }
            }

            updateValidationDisplay();
        }
    }
    
    private void handleSavePreset()
    {
        final Set<IProjectFacetVersion> facets = getSelectedProjectFacets();
        final IPreset preset = SavePresetDialog.showDialog( getShell(), facets );
        
        if( preset != null )
        {
            this.model.refreshAvailablePresets();
            this.model.setSelectedPreset( preset.getId() );
        }
    }
    
    private void handleDeletePreset()
    {
        final IPreset preset = this.model.getSelectedPreset();
        this.model.setSelectedPreset( null );
        ProjectFacetsManager.deletePreset( preset );
        this.model.refreshAvailablePresets();
    }
    
    private void handleShowHideRuntimes()
    {
        if( this.sform1.getMaximizedControl() == null )
        {
            this.sform1.setMaximizedControl( this.sform2 );
            this.showHideRuntimesButton.setText( Resources.showRuntimes );
        }
        else
        {
            this.sform1.setMaximizedControl( null );
            this.showHideRuntimesButton.setText( Resources.hideRuntimes );
        }
    }
    
    private void handleModelChangedEvent( final String event )
    {
        if( event.equals( ModifyFacetedProjectDataModel.EVENT_FIXED_FACETS_CHANGED ) )
        {
            for( TableRowData trd : this.data )
            {
                trd.setFixed( false );
            }

            for( IProjectFacet f : this.model.getFixedFacets() )
            {
                final TableRowData trd = findTableRowData( f, true );
                
                trd.setFixed( true );
                trd.setSelected( true );
                this.treeViewer.setChecked( trd, true );
            }

            refresh();
            updateValidationDisplay();
        }
        else if( event.equals( ModifyFacetedProjectDataModel.EVENT_SELECTED_PRESET_CHANGED ) )
        {
            final IPreset preset = this.model.getSelectedPreset();
            
            if( preset == null )
            {
                this.savePresetButton.setEnabled( true );
                this.deletePresetButton.setEnabled( false );
            }
            else
            {
                this.savePresetButton.setEnabled( false );
                this.deletePresetButton.setEnabled( preset.getType() == IPreset.Type.USER_DEFINED );
            }
        }
        else if( event.equals( ChangeTargetedRuntimesDataModel.EVENT_TARGETED_RUNTIMES_CHANGED ) )
        {
            refresh();
        }
    }
    
    private List<TreeItem> getAllTreeItems()
    {
        final List<TreeItem> result = new ArrayList<TreeItem>();
        getAllTreeItems( this.tree.getItems(), result );
        return result;
    }

    private static void getAllTreeItems( final TreeItem[] items,
                                         final List<TreeItem> result )
    {
        for( TreeItem item : items )
        {
            result.add( item );
            getAllTreeItems( item.getItems(), result );
        }
    }
    
    private TreeItem getTreeItem( final int x,
                                  final int y )
    {
        return getTreeItemHelper( x, y, this.tree.getItems() );
    }
    
    private static TreeItem getTreeItemHelper( final int x,
                                               final int y,
                                               final TreeItem[] items )
    {
        for( TreeItem item : items )
        {
            if( item.getBounds().contains( x, y ) )
            {
                return item;
            }
            
            final TreeItem res = getTreeItemHelper( x, y, item.getItems() );
            
            if( res != null )
            {
                return res;
            }
        }
        
        return null;
    }
    
    /*private TreeItem getTreeItem( final Object modelObject )
    {
        for( TreeItem item : getAllTreeItems() )
        {
            if( item.getData().equals( modelObject ) )
            {
                return item;
            }
        }
        
        return null;
    }*/
    
    private int computeDefaultFacetColumnWidth()
    {
        final GC gc = new GC( this.getDisplay() );
        int maxFacetLabelWidth = 0;
        
        try
        {
            gc.setFont( this.tree.getFont() );
            
            for( IProjectFacet f : ProjectFacetsManager.getProjectFacets() )
            {
                maxFacetLabelWidth = max( maxFacetLabelWidth, gc.textExtent( f.getLabel() ).x );
            }
        }
        finally
        {
            gc.dispose();
        }
        
        return max( maxFacetLabelWidth + 100, 200 );
    }

    private int computeDefaultVersionColumnWidth()
    {
        final GC gc = new GC( this.getDisplay() );
        int maxVersionStringWidth = 0;
        final int columnLabelWidth;
        
        try
        {
            gc.setFont( this.tree.getFont() );

            for( IProjectFacet f : ProjectFacetsManager.getProjectFacets() )
            {
                for( IProjectFacetVersion fv : f.getVersions() )
                {
                    final int textExtent = gc.textExtent( fv.getVersionString() ).x;
                    maxVersionStringWidth = max( maxVersionStringWidth, textExtent + 30 );
                }
            }

            columnLabelWidth = gc.textExtent( Resources.versionColumnLabel ).x + 30;
        }
        finally
        {
            gc.dispose();
        }
        
        return max( maxVersionStringWidth, columnLabelWidth );
    }
    
    private final class TableRowData
    {
        private IProjectFacet f;
        private List<IProjectFacetVersion> allVersionsSorted;
        private IProjectFacetVersion current;
        private boolean isSelected;
        private boolean isFixed;

        public TableRowData( final IProjectFacet f )
        
            throws CoreException
            
        {
            this.f = f;
            // TODO: Remove this unnecessary copy.
            this.allVersionsSorted = new ArrayList<IProjectFacetVersion>( f.getSortedVersions( false ) );
            this.current = f.getDefaultVersion();
            this.isSelected = false;
            this.isFixed = false;
        }

        public IProjectFacet getProjectFacet()
        {
            return this.f;
        }

        public List<IProjectFacetVersion> getVersions()
        {
            final Set<IProjectFacetVersion> versions
                = FacetsSelectionPanel.this.model.getAvailableFacets().get( this.f );
            
            if( versions == null )
            {
                return Collections.emptyList();
            }
            else
            {
                final List<IProjectFacetVersion> sortedVersions 
                    = new ArrayList<IProjectFacetVersion>( this.allVersionsSorted );
                
                sortedVersions.retainAll( versions );
                
                return sortedVersions;
            }
        }
        
        public void addUnknownVersion( final IProjectFacetVersion fv )
        {
            try
            {
                final Comparator<String> c = this.f.getVersionComparator();
                boolean added = false;
                
                for( int i = 0, n = this.allVersionsSorted.size(); i < n; i++ )
                {
                    final IProjectFacetVersion x = this.allVersionsSorted.get( i );
                    
                    if( c.compare( x.getVersionString(), fv.getVersionString() ) < 0 )
                    {
                        this.allVersionsSorted.add( i, fv );
                        added = true;
                        break;
                    }
                }
                
                if( ! added )
                {
                    this.allVersionsSorted.add( fv );
                }
            }
            catch( CoreException e )
            {
                FacetUiPlugin.log( e );
            }
        }

        public IProjectFacetVersion getCurrentVersion()
        {
            final Set<IProjectFacetVersion> versions
                = FacetsSelectionPanel.this.model.getAvailableFacets().get( this.f );
            
            if( versions == null )
            {
                if( this.current != null )
                {
                    this.current = null;
                }
            }
            else
            {
                if( ! versions.contains( this.current ) )
                {
                    this.current = getVersions().get( 0 );
                }
            }

            return this.current;
        }

        public void setCurrentVersion( final IProjectFacetVersion fv )
        {
            this.current = fv;
        }

        public boolean isSelected()
        {
            if( getVersions().isEmpty() )
            {
                this.isSelected = false;
            }

            return this.isSelected;
        }

        public void setSelected( final boolean isSelected )
        {
            this.isSelected = isSelected;
        }

        public boolean isFixed()
        {
            return this.isFixed;
        }

        public void setFixed( final boolean isFixed )
        {
            this.isFixed = isFixed;
        }

        public boolean isVisible()
        {
            return ! getVersions().isEmpty();
        }
        
        public String toString()
        {
            return this.current.toString();
        }
    }

    private final class ContentProvider

        implements ITreeContentProvider

    {
        public Object[] getElements( final Object element )
        {
            final List<Object> list = new ArrayList<Object>();
            final Set<ICategory> categories = ProjectFacetsManager.getCategories();

            for( ICategory cat : categories )
            {
                boolean visible = false;

                for( IProjectFacet f : cat.getProjectFacets() )
                {
                    if( findTableRowData( f ).isVisible() )
                    {
                        visible = true;
                        break;
                    }
                }

                if( visible )
                {
                    list.add( cat );
                }
            }

            for( TableRowData trd : FacetsSelectionPanel.this.data )
            {
                if( trd.getProjectFacet().getCategory() == null && trd.isVisible() )
                {
                    list.add( trd );
                }
            }

            return list.toArray();
        }

        public Object[] getChildren( final Object parent )
        {
            if( parent instanceof ICategory )
            {
                final ICategory category = (ICategory) parent;
                final List<TableRowData> trds = new ArrayList<TableRowData>();

                for( IProjectFacet f : category.getProjectFacets() )
                {
                    final TableRowData trd = findTableRowData( f );

                    if( trd.isVisible() )
                    {
                        trds.add( trd );
                    }
                }

                return trds.toArray();
            }
            else
            {
                return new Object[ 0 ];
            }
        }

        public Object getParent( final Object element )
        {
            if( element instanceof TableRowData )
            {
                final IProjectFacet f 
                    = ( (TableRowData) element ).getProjectFacet();

                return f.getCategory();
            }
            else
            {
                return null;
            }
        }

        public boolean hasChildren( final Object element )
        {
            return ( element instanceof ICategory ) &&
                   ! ( (ICategory) element ).getProjectFacets().isEmpty();
        }

        public void dispose() { }

        public void inputChanged( final Viewer viewer,
                                  final Object oldObject,
                                  final Object newObject ) {}
    }

    private final class LabelProvider

        implements ITableLabelProvider

    {
        public String getColumnText( final Object element,
                                     final int column )
        {
            if( element instanceof ICategory )
            {
                if( column == 0 )
                {
                    return ( (ICategory) element ).getLabel();
                }
                else
                {
                    return ""; //$NON-NLS-1$
                }
            }
            else
            {
                final TableRowData trd = (TableRowData) element;

                switch( column )
                {
                    case 0:
                    {
                        return trd.getProjectFacet().getLabel();
                    }
                    case 1:
                    {
                        return trd.getCurrentVersion().getVersionString();
                    }
                    default:
                    {
                        throw new IllegalStateException();
                    }
                }
            }
        }

        public Image getColumnImage( final Object element,
                                     final int column )
        {
            if( column != 0 )
            {
                return null;
            }
            
            String id;
            IAdaptable obj;
            boolean isFixed = false;

            if( element instanceof TableRowData )
            {
                final TableRowData trd = (TableRowData) element;
                final IProjectFacet f = trd.getProjectFacet();

                isFixed = trd.isFixed;
                id = ( isFixed ? "F:" : "f:" ) + f.getId(); //$NON-NLS-1$ //$NON-NLS-2$
                obj = f;
            }
            else
            {
                id = "c:" + ( (ICategory) element ).getId(); //$NON-NLS-1$
                obj = (IAdaptable) element;
            }
            
            Image image = getImageRegistry().get( id );
            
            if( image == null )
            {
                final IDecorationsProvider decprov
                    = (IDecorationsProvider) obj.getAdapter( IDecorationsProvider.class );
                
                ImageDescriptor imgdesc = decprov.getIcon();
                
                if( isFixed )
                {
                    imgdesc = new FixedFacetImageDescriptor( imgdesc );
                }
                
                getImageRegistry().put( id, imgdesc );
                image = getImageRegistry().get( id );
            }

            return image;
        }

        public boolean isLabelProperty( final Object obj,
                                        final String s )
        {
            return false;
        }
        
        public void dispose() {}
        public void addListener( final ILabelProviderListener listener ) {}
        public void removeListener( ILabelProviderListener listener ) {}
    }

    private static final class FixedFacetImageDescriptor 
    
        extends CompositeImageDescriptor 
        
    {
        private static final String OVERLAY_IMG_LOCATION
            = "images/lock.gif"; //$NON-NLS-1$
        
        private static final ImageData OVERLAY
            = FacetUiPlugin.getImageDescriptor( OVERLAY_IMG_LOCATION ).getImageData();
        
        private final ImageData base;
        private final Point size;
        
        public FixedFacetImageDescriptor( final ImageDescriptor base ) 
        {
            this.base = base.getImageData();
            this.size = new Point( this.base.width, this.base.height ); 
        }

        protected void drawCompositeImage( final int width, 
                                           final int height ) 
        {
            drawImage( this.base, 0, 0 );
            drawImage( OVERLAY, 0, height - OVERLAY.height );
        }

        protected Point getSize()
        {
            return this.size;
        }
    }
    
    private final class CellModifier

        implements ICellModifier

    {
        public Object getValue( final Object element,
                                final String property )
        {
            final TableRowData trd = (TableRowData) element;

            if( property.equals( VERSION_COLUMN ) )
            {
                final List<IProjectFacetVersion> versions = trd.getVersions();

                for( int i = 0, n = versions.size(); i < n; i++ )
                {
                    if( versions.get( i ) == trd.getCurrentVersion() )
                    {
                        return new Integer( i );
                    }
                }

                return new IllegalStateException();
            }
            else
            {
                throw new IllegalStateException();
            }
        }

        public boolean canModify( final Object element,
                                  final String property )
        {
            return property.equals( VERSION_COLUMN ) &&
                   element instanceof TableRowData &&
                   ( (TableRowData) element ).getVersions().size() > 1;
        }

        public void modify( final Object element,
                            final String property,
                            final Object value )
        {
            final TreeItem item = (TreeItem) element;
            final TableRowData trd = (TableRowData) item.getData();

            if( property.equals( VERSION_COLUMN ) )
            {
                final int index = ( (Integer) value ).intValue();

                if( index != -1 )
                {
                    final IProjectFacetVersion fv = trd.getVersions().get( index );
                    
                    if( trd.getCurrentVersion() != fv )
                    {
                        trd.setCurrentVersion( fv );
                        FacetsSelectionPanel.this.treeViewer.update( trd, null );
                        
                        if( trd.isSelected() )
                        {
                            FacetsSelectionPanel.this.model.setSelectedPreset( null );
                        }
    
                        updateValidationDisplay();
                    }
                }
            }
            else
            {
                throw new IllegalStateException();
            }
        }
    }

    private static final class Sorter

        extends ViewerSorter

    {
        public int compare( final Viewer viewer,
                            final Object a,
                            final Object b )
        {
            return getLabel( a ).compareToIgnoreCase( getLabel( b ) );
        }

        private static String getLabel( final Object obj )
        {
            if( obj instanceof TableRowData )
            {
                return ( (TableRowData) obj ).getProjectFacet().getLabel();
            }
            else
            {
                return ( (ICategory) obj ).getLabel();
            }
        }
    }
    
    private final class FacetToolTip
    
        extends HeaderToolTip
        
    {
        public FacetToolTip( final Control control )
        {
            super( control );
        }
        
        @Override
        protected final boolean shouldCreateToolTip( final Event event ) 
        {
            final TreeItem treeItem = getTreeItem( event.x, event.y );
            String description = null;
            
            if( treeItem != null && treeItem.getBounds( 0 ).contains( event.x, event.y ) )
            {
                final Object treeItemData = treeItem.getData();
                
                if( treeItemData instanceof TableRowData )
                {
                    final IProjectFacetVersion fv 
                        = ( (TableRowData) treeItemData ).getCurrentVersion();
                    
                    description = fv.getProjectFacet().getDescription();
                }
            }
            
            return ( description != null && description.trim().length() > 0 );
        }

        @Override
        protected String getToolTipTitle( final Event event )
        {
            final TableRowData trd = (TableRowData) getTreeItem( event.x, event.y ).getData();
            return trd.getCurrentVersion().toString();
        }

        @Override
        protected Composite createContentArea( final Event event,
                                               final Composite parent )
        {
            final Display display = parent.getDisplay();
            
            final Composite composite = new Composite( parent, SWT.NONE );
            composite.setLayout( gl( 1 ) );
            composite.setBackground( display.getSystemColor( SWT.COLOR_INFO_BACKGROUND ) );
            
            final Label label = new Label( composite, SWT.WRAP );
            label.setLayoutData( gdfill() );
            label.setBackground( display.getSystemColor( SWT.COLOR_INFO_BACKGROUND ) );

            final TableRowData trd = (TableRowData) getTreeItem( event.x, event.y ).getData();
            label.setText( trd.getCurrentVersion().getProjectFacet().getDescription() );
            
            return composite;
        }
    }

    private final class CategoryToolTip
    
        extends HeaderToolTip
        
    {
        public CategoryToolTip( final Control control )
        {
            super( control );
        }
        
        @Override
        protected final boolean shouldCreateToolTip( final Event event ) 
        {
            final TreeItem treeItem = getTreeItem( event.x, event.y );
            String description = null;
            
            if( treeItem != null && treeItem.getBounds( 0 ).contains( event.x, event.y ) )
            {
                final Object treeItemData = treeItem.getData();
                
                if( treeItemData instanceof ICategory )
                {
                    description = ( (ICategory) treeItemData ).getDescription();
                }
            }
            
            return ( description != null && description.trim().length() > 0 );
        }
    
        @Override
        protected String getToolTipTitle( final Event event )
        {
            return ( (ICategory) getTreeItem( event.x, event.y ).getData() ).getLabel();
        }
    
        @Override
        protected Composite createContentArea( final Event event,
                                               final Composite parent )
        {
            final Display display = parent.getDisplay();
            
            final Composite composite = new Composite( parent, SWT.NONE );
            composite.setLayout( gl( 1 ) );
            composite.setBackground( display.getSystemColor( SWT.COLOR_INFO_BACKGROUND ) );
            
            final Label label = new Label( composite, SWT.WRAP );
            label.setLayoutData( gdfill() );
            label.setBackground( display.getSystemColor( SWT.COLOR_INFO_BACKGROUND ) );
    
            final ICategory category = (ICategory) getTreeItem( event.x, event.y ).getData();
            label.setText( category.getDescription() );
            
            return composite;
        }
    }

    private final class FixedFacetToolTip
    
        extends BasicToolTip
        
    {
        private static final int FAKE_EVENT_TYPE = -9999;
        
        public FixedFacetToolTip( final Control control )
        {
            super( control );
            setPopupDelay( 0 );
        }
        
        public void show( final Point location )
        {
            // The JFace ToolTip class does not support alternative methods of tool tip activation.
            // An enhancement request https://bugs.eclipse.org/bugs/show_bug.cgi?id=174844 tracks
            // this issue. When that enhancement request has been resolved, this hacky 
            // implementation should be replaced with something more sensible.
            
            final Event fakeEvent = new Event();
            fakeEvent.type = FAKE_EVENT_TYPE;
            fakeEvent.x = location.x;
            fakeEvent.y = location.y;
            
            try
            {
                final Method method
                    = ToolTip.class.getDeclaredMethod( "toolTipCreate", Event.class ); //$NON-NLS-1$
                
                method.setAccessible( true );
                method.invoke( this, fakeEvent );
            }
            catch( Exception e )
            {
                FacetUiPlugin.log( e );
            }
        }
        
        @Override
        protected final boolean shouldCreateToolTip( final Event event ) 
        {
            return ( event.type == FAKE_EVENT_TYPE );
        }
    }
    
    private final class ProblemsContentProvider

        implements IStructuredContentProvider

    {
        public Object[] getElements( final Object element )
        {
            return FacetsSelectionPanel.this.problems.getChildren();
        }

        public void dispose() { }

        public void inputChanged( final Viewer viewer,
                                  final Object oldObject,
                                  final Object newObject ) {}
    }

    private final class ProblemsLabelProvider

        implements ITableLabelProvider

    {
        public String getColumnText( final Object element,
                                     final int column )
        {
            return ( (IStatus) element ).getMessage();
        }

        public Image getColumnImage( final Object element,
                                     final int column )
        {
            final IStatus st = (IStatus) element;
            
            if( st.getSeverity() == IStatus.ERROR )
            {
                return getImageRegistry().get( IMG_ERROR );
            }
            else
            {
                return getImageRegistry().get( IMG_WARNING );
            }
        }

        public boolean isLabelProperty( final Object obj,
                                        final String s )
        {
            return false;
        }

        public void dispose() {}
        public void addListener( final ILabelProviderListener listener ) {}
        public void removeListener( ILabelProviderListener listener ) {}
    }
    
    private static final class Resources
    
        extends NLS
        
    {
        public static String presetsLabel;
        public static String customPreset;
        public static String saveButtonLabel;
        public static String deleteButtonLabel;
        public static String savePresetDialogTitle;
        public static String savePresetDialogMessage;
        public static String facetColumnLabel;
        public static String versionColumnLabel;
        public static String showConstraints;
        public static String showRuntimes;
        public static String hideRuntimes;
        public static String couldNotDeselectFixedFacetMessage;
        public static String facetNotFound;
        public static String facetVersionNotFound;
        
        static
        {
            initializeMessages( FacetsSelectionPanel.class.getName(), 
                                Resources.class );
        }
        
        public static String bind( final String msg,
                                   final Object arg1,
                                   final Object arg2,
                                   final Object arg3 )
        {
            return NLS.bind( msg, new Object[] { arg1, arg2, arg3 } );
        }
    }
    
}