EDIT

// $Id$

/**

* Copyright (C) 2016 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.taxeditor.ui.dialog.selection;

import java.io.IOException;

import java.io.StringReader;

import java.io.StringWriter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import org.eclipse.core.commands.AbstractHandler;

import org.eclipse.core.commands.ExecutionEvent;

import org.eclipse.core.commands.IHandler;

import org.eclipse.core.runtime.Assert;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.ListenerList;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.ProgressMonitorWrapper;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.jface.action.Action;

import org.eclipse.jface.action.ActionContributionItem;

import org.eclipse.jface.action.IAction;

import org.eclipse.jface.action.IMenuListener;

import org.eclipse.jface.action.IMenuManager;

import org.eclipse.jface.action.LegacyActionTools;

import org.eclipse.jface.action.MenuManager;

import org.eclipse.jface.dialogs.IDialogSettings;

import org.eclipse.jface.viewers.ContentViewer;

import org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider.IStyledLabelProvider;

import org.eclipse.jface.viewers.DoubleClickEvent;

import org.eclipse.jface.viewers.IColorProvider;

import org.eclipse.jface.viewers.IContentProvider;

import org.eclipse.jface.viewers.IDoubleClickListener;

import org.eclipse.jface.viewers.IFontProvider;

import org.eclipse.jface.viewers.ILabelDecorator;

import org.eclipse.jface.viewers.ILabelProvider;

import org.eclipse.jface.viewers.ILabelProviderListener;

import org.eclipse.jface.viewers.ILazyContentProvider;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ISelectionChangedListener;

import org.eclipse.jface.viewers.IStructuredContentProvider;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.jface.viewers.LabelProviderChangedEvent;

import org.eclipse.jface.viewers.SelectionChangedEvent;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.StyledCellLabelProvider;

import org.eclipse.jface.viewers.StyledString;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerCell;

import org.eclipse.jface.viewers.ViewerFilter;

import org.eclipse.osgi.util.NLS;

import org.eclipse.swt.SWT;

import org.eclipse.swt.accessibility.ACC;

import org.eclipse.swt.accessibility.AccessibleAdapter;

import org.eclipse.swt.accessibility.AccessibleEvent;

import org.eclipse.swt.custom.CLabel;

import org.eclipse.swt.custom.ViewForm;

import org.eclipse.swt.events.KeyAdapter;

import org.eclipse.swt.events.KeyEvent;

import org.eclipse.swt.events.ModifyEvent;

import org.eclipse.swt.events.ModifyListener;

import org.eclipse.swt.events.MouseAdapter;

import org.eclipse.swt.events.MouseEvent;

import org.eclipse.swt.events.SelectionAdapter;

import org.eclipse.swt.events.SelectionEvent;

import org.eclipse.swt.events.TraverseEvent;

import org.eclipse.swt.events.TraverseListener;

import org.eclipse.swt.graphics.Color;

import org.eclipse.swt.graphics.Font;

import org.eclipse.swt.graphics.GC;

import org.eclipse.swt.graphics.Image;

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.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.Menu;

import org.eclipse.swt.widgets.Shell;

import org.eclipse.swt.widgets.Table;

import org.eclipse.swt.widgets.Text;

import org.eclipse.swt.widgets.ToolBar;

import org.eclipse.swt.widgets.ToolItem;

import org.eclipse.ui.ActiveShellExpression;

import org.eclipse.ui.IMemento;

import org.eclipse.ui.IWorkbenchCommandConstants;

import org.eclipse.ui.IWorkbenchPreferenceConstants;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.WorkbenchException;

import org.eclipse.ui.XMLMemento;

import org.eclipse.ui.dialogs.FilteredItemsSelectionDialog;

import org.eclipse.ui.dialogs.SearchPattern;

import org.eclipse.ui.dialogs.SelectionStatusDialog;

import org.eclipse.ui.handlers.IHandlerActivation;

import org.eclipse.ui.handlers.IHandlerService;

import org.eclipse.ui.internal.IWorkbenchGraphicConstants;

import org.eclipse.ui.internal.WorkbenchImages;

import org.eclipse.ui.internal.WorkbenchMessages;

import org.eclipse.ui.internal.WorkbenchPlugin;

import org.eclipse.ui.progress.UIJob;

import org.eclipse.ui.statushandlers.StatusManager;

/**

 * @author k.luther

 * @date 10.06.2016

 *

 */

public abstract class CdmFilteredItemsSelectionDialog extends SelectionStatusDialog {

        private static final String DIALOG_BOUNDS_SETTINGS = "DialogBoundsSettings"; //$NON-NLS-1$

        private static final String SHOW_STATUS_LINE = "ShowStatusLine"; //$NON-NLS-1$

        private static final String HISTORY_SETTINGS = "History"; //$NON-NLS-1$

        private static final String DIALOG_HEIGHT = "DIALOG_HEIGHT"; //$NON-NLS-1$

        private static final String DIALOG_WIDTH = "DIALOG_WIDTH"; //$NON-NLS-1$

        /**

         * Represents an empty selection in the pattern input field (used only for

         * initial pattern).

         */

        public static final int NONE = 0;

        /**

         * Pattern input field selection where caret is at the beginning (used only

         * for initial pattern).

         */

        public static final int CARET_BEGINNING = 1;

        /**

         * Represents a full selection in the pattern input field (used only for

         * initial pattern).

         */

        public static final int FULL_SELECTION = 2;

        private Text pattern;

        private TableViewer list;

        private DetailsContentViewer details;

        /**

         * It is a duplicate of a field in the CLabel class in DetailsContentViewer.

         * It is maintained, because the <code>setDetailsLabelProvider()</code>

         * could be called before content area is created.

         */

        private ILabelProvider detailsLabelProvider;

        private ItemsListLabelProvider itemsListLabelProvider;

        private MenuManager menuManager;

        private MenuManager contextMenuManager;

        private final boolean multi;

        private ToolBar toolBar;

        private ToolItem toolItem;

        private Label progressLabel;

        private ToggleStatusLineAction toggleStatusLineAction;

        private RemoveHistoryItemAction removeHistoryItemAction;

        private ActionContributionItem removeHistoryActionContributionItem;

        private IStatus status;

        private final RefreshCacheJob refreshCacheJob;

        private final RefreshProgressMessageJob refreshProgressMessageJob = new RefreshProgressMessageJob();

        private Object[] currentSelection;

        private final ContentProvider contentProvider;

        private final FilterHistoryJob filterHistoryJob;

        private final FilterJob filterJob;

        private ItemsFilter filter;

        private List lastCompletedResult;

        private ItemsFilter lastCompletedFilter;

        private String initialPatternText;

        private int selectionMode;

        private ItemsListSeparator itemsListSeparator;

        private static final String EMPTY_STRING = ""; //$NON-NLS-1$

        private boolean refreshWithLastSelection = false;

        private IHandlerActivation showViewHandler;

        /**

         * Creates a new instance of the class.

         *

         * @param shell

         *            shell to parent the dialog on

         * @param multi

         *            indicates whether dialog allows to select more than one

         *            position in its list of items

         */

        public CdmFilteredItemsSelectionDialog(Shell shell, boolean multi) {

            super(shell);

            this.multi = multi;

            filterHistoryJob = new FilterHistoryJob();

            filterJob = new FilterJob();

            contentProvider = new ContentProvider();

            refreshCacheJob = new RefreshCacheJob();

            itemsListSeparator = new ItemsListSeparator(

                    WorkbenchMessages.FilteredItemsSelectionDialog_separatorLabel);

            selectionMode = NONE;

        }

        /**

         * Creates a new instance of the class. Created dialog won't allow to select

         * more than one item.

         *

         * @param shell

         *            shell to parent the dialog on

         */

        public CdmFilteredItemsSelectionDialog(Shell shell) {

            this(shell, false);

        }

        /**

         * Adds viewer filter to the dialog items list.

         *

         * @param filter

         *            the new filter

         */

        protected void addListFilter(ViewerFilter filter) {

            contentProvider.addFilter(filter);

        }

        /**

         * Sets a new label provider for items in the list. If the label provider

         * also implements {@link

         * org.eclipse.jface.viewers.DelegatingStyledCellLabelProvider

         * .IStyledLabelProvider}, the style text labels provided by it will be used

         * provided that the corresponding preference is set.

         *

         * @see IWorkbenchPreferenceConstants#USE_COLORED_LABELS

         *

         * @param listLabelProvider

         *      the label provider for items in the list

         */

        public void setListLabelProvider(ILabelProvider listLabelProvider) {

            getItemsListLabelProvider().setProvider(listLabelProvider);

        }

        /**

         * Returns the label decorator for selected items in the list.

         *

         * @return the label decorator for selected items in the list

         */

        private ILabelDecorator getListSelectionLabelDecorator() {

            return getItemsListLabelProvider().getSelectionDecorator();

        }

        /**

         * Sets the label decorator for selected items in the list.

         *

         * @param listSelectionLabelDecorator

         *            the label decorator for selected items in the list

         */

        public void setListSelectionLabelDecorator(

                ILabelDecorator listSelectionLabelDecorator) {

            getItemsListLabelProvider().setSelectionDecorator(

                    listSelectionLabelDecorator);

        }

        /**

         * Returns the item list label provider.

         *

         * @return the item list label provider

         */

        private ItemsListLabelProvider getItemsListLabelProvider() {

            if (itemsListLabelProvider == null) {

                itemsListLabelProvider = new ItemsListLabelProvider(

                        new LabelProvider(), null);

            }

            return itemsListLabelProvider;

        }

        /**

         * Sets label provider for the details field.

         *

         * For a single selection, the element sent to

         * {@link ILabelProvider#getImage(Object)} and

         * {@link ILabelProvider#getText(Object)} is the selected object, for

         * multiple selection a {@link String} with amount of selected items is the

         * element.

         *

         * @see #getSelectedItems() getSelectedItems() can be used to retrieve

         *      selected items and get the items count.

         *

         * @param detailsLabelProvider

         *            the label provider for the details field

         */

        public void setDetailsLabelProvider(ILabelProvider detailsLabelProvider) {

            this.detailsLabelProvider = detailsLabelProvider;

            if (details != null) {

                details.setLabelProvider(detailsLabelProvider);

            }

        }

        private ILabelProvider getDetailsLabelProvider() {

            if (detailsLabelProvider == null) {

                detailsLabelProvider = new LabelProvider();

            }

            return detailsLabelProvider;

        }

        /*

         * (non-Javadoc)

         *

         * @see org.eclipse.jface.window.Window#create()

         */

        @Override

        public void create() {

            super.create();

            pattern.setFocus();

        }

        /**

         * Restores dialog using persisted settings. The default implementation

         * restores the status of the details line and the selection history.

         *

         * @param settings

         *            settings used to restore dialog

         */

        protected void restoreDialog(IDialogSettings settings) {

            boolean toggleStatusLine = true;

            if (settings.get(SHOW_STATUS_LINE) != null) {

                toggleStatusLine = settings.getBoolean(SHOW_STATUS_LINE);

            }

            toggleStatusLineAction.setChecked(toggleStatusLine);

            details.setVisible(toggleStatusLine);

            String setting = settings.get(HISTORY_SETTINGS);

            if (setting != null) {

                try {

                    IMemento memento = XMLMemento.createReadRoot(new StringReader(

                            setting));

                    this.contentProvider.loadHistory(memento);

                } catch (WorkbenchException e) {

                    // Simply don't restore the settings

                    StatusManager

                            .getManager()

                            .handle(

                                    new Status(

                                            IStatus.ERROR,

                                            PlatformUI.PLUGIN_ID,

                                            IStatus.ERROR,

                                            WorkbenchMessages.FilteredItemsSelectionDialog_restoreError,

                                            e));

                }

            }

        }

        /*

         * (non-Javadoc)

         *

         * @see org.eclipse.jface.window.Window#close()

         */

        @Override

        public boolean close() {

            this.filterJob.cancel();

            this.refreshCacheJob.cancel();

            this.refreshProgressMessageJob.cancel();

            if (showViewHandler != null) {

                IHandlerService service = (IHandlerService) PlatformUI

                        .getWorkbench().getService(IHandlerService.class);

                service.deactivateHandler(showViewHandler);

                showViewHandler.getHandler().dispose();

                showViewHandler = null;

            }

            if (menuManager != null) {

                menuManager.dispose();

            }

            if (contextMenuManager != null) {

                contextMenuManager.dispose();

            }

            storeDialog(getDialogSettings());

            return super.close();

        }

        /**

         * Stores dialog settings.

         *

         * @param settings

         *            settings used to store dialog

         */

        protected void storeDialog(IDialogSettings settings) {

            settings.put(SHOW_STATUS_LINE, toggleStatusLineAction.isChecked());

            XMLMemento memento = XMLMemento.createWriteRoot(HISTORY_SETTINGS);

            this.contentProvider.saveHistory(memento);

            StringWriter writer = new StringWriter();

            try {

                memento.save(writer);

                settings.put(HISTORY_SETTINGS, writer.getBuffer().toString());

            } catch (IOException e) {

                // Simply don't store the settings

                StatusManager

                        .getManager()

                        .handle(

                                new Status(

                                        IStatus.ERROR,

                                        PlatformUI.PLUGIN_ID,

                                        IStatus.ERROR,

                                        WorkbenchMessages.FilteredItemsSelectionDialog_storeError,

                                        e));

            }

        }

        /**

         * Create a new header which is labelled by headerLabel.

         *

         * @param parent

         * @return Label the label of the header

         */

        private Label createHeader(Composite parent) {

            Composite header = new Composite(parent, SWT.NONE);

            GridLayout layout = new GridLayout();

            layout.numColumns = 2;

            layout.marginWidth = 0;

            layout.marginHeight = 0;

            header.setLayout(layout);

            Label headerLabel = new Label(header, SWT.NONE);

            headerLabel.setText((getMessage() != null && getMessage().trim()

                    .length() > 0) ? getMessage()

                    : WorkbenchMessages.FilteredItemsSelectionDialog_patternLabel);

            headerLabel.addTraverseListener(new TraverseListener() {

                @Override

                public void keyTraversed(TraverseEvent e) {

                    if (e.detail == SWT.TRAVERSE_MNEMONIC && e.doit) {

                        e.detail = SWT.TRAVERSE_NONE;

                        pattern.setFocus();

                    }

                }

            });

            GridData gd = new GridData(GridData.FILL_HORIZONTAL);

            headerLabel.setLayoutData(gd);

            createViewMenu(header);

            header.setLayoutData(gd);

            return headerLabel;

        }

        /**

         * Create the labels for the list and the progress. Return the list label.

         *

         * @param parent

         * @return Label

         */

        private Label createLabels(Composite parent) {

            Composite labels = new Composite(parent, SWT.NONE);

            GridLayout layout = new GridLayout();

            layout.numColumns = 2;

            layout.marginWidth = 0;

            layout.marginHeight = 0;

            labels.setLayout(layout);

            Label listLabel = new Label(labels, SWT.NONE);

            listLabel

                    .setText(WorkbenchMessages.FilteredItemsSelectionDialog_listLabel);

            listLabel.addTraverseListener(new TraverseListener() {

                @Override

                public void keyTraversed(TraverseEvent e) {

                    if (e.detail == SWT.TRAVERSE_MNEMONIC && e.doit) {

                        e.detail = SWT.TRAVERSE_NONE;

                        list.getTable().setFocus();

                    }

                }

            });

            GridData gd = new GridData(GridData.FILL_HORIZONTAL);

            listLabel.setLayoutData(gd);

            progressLabel = new Label(labels, SWT.RIGHT);

            progressLabel.setLayoutData(gd);

            labels.setLayoutData(gd);

            return listLabel;

        }

        private void createViewMenu(Composite parent) {

            toolBar = new ToolBar(parent, SWT.FLAT);

            toolItem = new ToolItem(toolBar, SWT.PUSH, 0);

            GridData data = new GridData();

            data.horizontalAlignment = GridData.END;

            toolBar.setLayoutData(data);

            toolBar.addMouseListener(new MouseAdapter() {

                @Override

                public void mouseDown(MouseEvent e) {

                    showViewMenu();

                }

            });

            toolItem.setImage(WorkbenchImages

                    .getImage(IWorkbenchGraphicConstants.IMG_LCL_VIEW_MENU));

            toolItem

                    .setToolTipText(WorkbenchMessages.FilteredItemsSelectionDialog_menu);

            toolItem.addSelectionListener(new SelectionAdapter() {

                @Override

                public void widgetSelected(SelectionEvent e) {

                    showViewMenu();

                }

            });

            menuManager = new MenuManager();

            fillViewMenu(menuManager);

            IHandlerService service = (IHandlerService) PlatformUI.getWorkbench()

                    .getService(IHandlerService.class);

            IHandler handler = new AbstractHandler() {

                @Override

                public Object execute(ExecutionEvent event) {

                    showViewMenu();

                    return null;

                }

            };

            showViewHandler = service.activateHandler(

                    IWorkbenchCommandConstants.WINDOW_SHOW_VIEW_MENU, handler,

                    new ActiveShellExpression(getShell()));

        }

        /**

         * Fills the menu of the dialog.

         *

         * @param menuManager

         *            the menu manager

         */

        protected void fillViewMenu(IMenuManager menuManager) {

            toggleStatusLineAction = new ToggleStatusLineAction();

            menuManager.add(toggleStatusLineAction);

        }

        private void showViewMenu() {

            Menu menu = menuManager.createContextMenu(getShell());

            Rectangle bounds = toolItem.getBounds();

            Point topLeft = new Point(bounds.x, bounds.y + bounds.height);

            topLeft = toolBar.toDisplay(topLeft);

            menu.setLocation(topLeft.x, topLeft.y);

            menu.setVisible(true);

        }

        /**

         * Hook that allows to add actions to the context menu.

         * <p>

         * Subclasses may extend in order to add other actions.</p>

         *

         * @param menuManager the context menu manager

         * @since 3.5

         */

        protected void fillContextMenu(IMenuManager menuManager) {

            List selectedElements= ((StructuredSelection)list.getSelection()).toList();

            Object item= null;

            for (Iterator it= selectedElements.iterator(); it.hasNext();) {

                item= it.next();

                if (item instanceof ItemsListSeparator || !isHistoryElement(item)) {

                    return;

                }

            }

            if (selectedElements.size() > 0) {

                removeHistoryItemAction.setText(WorkbenchMessages.FilteredItemsSelectionDialog_removeItemsFromHistoryAction);

                menuManager.add(removeHistoryActionContributionItem);

            }

        }

        private void createPopupMenu() {

            removeHistoryItemAction = new RemoveHistoryItemAction();

            removeHistoryActionContributionItem = new ActionContributionItem(

                    removeHistoryItemAction);

            contextMenuManager = new MenuManager();

            contextMenuManager.setRemoveAllWhenShown(true);

            contextMenuManager.addMenuListener(new IMenuListener() {

                @Override

                public void menuAboutToShow(IMenuManager manager) {

                    fillContextMenu(manager);

                }

            });

            final Table table = list.getTable();

            Menu menu= contextMenuManager.createContextMenu(table);

            table.setMenu(menu);

        }

        /**

         * Creates an extra content area, which will be located above the details.

         *

         * @param parent

         *            parent to create the dialog widgets in

         * @return an extra content area

         */

        protected abstract Control createExtendedContentArea(Composite parent);

        /*

         * (non-Javadoc)

         *

         * @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)

         */

        @Override

        protected Control createDialogArea(Composite parent) {

            Composite dialogArea = (Composite) super.createDialogArea(parent);

            Composite content = new Composite(dialogArea, SWT.NONE);

            GridData gd = new GridData(GridData.FILL_BOTH);

            content.setLayoutData(gd);

            GridLayout layout = new GridLayout();

            layout.numColumns = 1;

            layout.marginWidth = 0;

            layout.marginHeight = 0;

            content.setLayout(layout);

            final Label headerLabel = createHeader(content);

            pattern = new Text(content, SWT.SINGLE | SWT.BORDER | SWT.SEARCH | SWT.ICON_CANCEL);

            pattern.getAccessible().addAccessibleListener(new AccessibleAdapter() {

                @Override

                public void getName(AccessibleEvent e) {

                    e.result = LegacyActionTools.removeMnemonics(headerLabel

                            .getText());

                }

            });

            gd = new GridData(GridData.FILL_HORIZONTAL);

            pattern.setLayoutData(gd);

            final Label listLabel = createLabels(content);

            list = new TableViewer(content, (multi ? SWT.MULTI : SWT.SINGLE)

                    | SWT.BORDER | SWT.V_SCROLL | SWT.VIRTUAL);

            list.getTable().getAccessible().addAccessibleListener(

                    new AccessibleAdapter() {

                        @Override

                        public void getName(AccessibleEvent e) {

                            if (e.childID == ACC.CHILDID_SELF) {

                                e.result = LegacyActionTools

                                        .removeMnemonics(listLabel.getText());

                            }

                        }

                    });

            list.setContentProvider(contentProvider);

            list.setLabelProvider(getItemsListLabelProvider());

            list.setInput(new Object[0]);

            list.setItemCount(contentProvider.getNumberOfElements());

            gd = new GridData(GridData.FILL_BOTH);

            applyDialogFont(list.getTable());

            gd.heightHint= list.getTable().getItemHeight() * 15;

            list.getTable().setLayoutData(gd);

            createPopupMenu();

            pattern.addModifyListener(new ModifyListener() {

                @Override

                public void modifyText(ModifyEvent e) {

                    applyFilter();

                }

            });

            pattern.addKeyListener(new KeyAdapter() {

                @Override

                public void keyPressed(KeyEvent e) {

                    if (e.keyCode == SWT.ARROW_DOWN) {

                        if (list.getTable().getItemCount() > 0) {

                            list.getTable().setFocus();

                        }

                    }

                }

            });

            list.addSelectionChangedListener(new ISelectionChangedListener() {

                @Override

                public void selectionChanged(SelectionChangedEvent event) {

                    StructuredSelection selection = (StructuredSelection) event

                            .getSelection();

                    handleSelected(selection);

                }

            });

            list.addDoubleClickListener(new IDoubleClickListener() {

                @Override

                public void doubleClick(DoubleClickEvent event) {

                    handleDoubleClick();

                }

            });

            list.getTable().addKeyListener(new KeyAdapter() {

                @Override

                public void keyPressed(KeyEvent e) {

                    if (e.keyCode == SWT.DEL) {

                        List selectedElements = ((StructuredSelection) list

                                .getSelection()).toList();

                        Object item = null;

                        boolean isSelectedHistory = true;

                        for (Iterator it = selectedElements.iterator(); it

                                .hasNext();) {

                            item = it.next();

                            if (item instanceof ItemsListSeparator

                                    || !isHistoryElement(item)) {

                                isSelectedHistory = false;

                                break;

                            }

                        }

                        if (isSelectedHistory) {

                            removeSelectedItems(selectedElements);

                        }

                    }

                    if (e.keyCode == SWT.ARROW_UP && (e.stateMask & SWT.SHIFT) != 0

                            && (e.stateMask & SWT.CTRL) != 0) {

                        StructuredSelection selection = (StructuredSelection) list

                                .getSelection();

                        if (selection.size() == 1) {

                            Object element = selection.getFirstElement();

                            if (element.equals(list.getElementAt(0))) {

                                pattern.setFocus();

                            }

                            if (list.getElementAt(list.getTable()

                                    .getSelectionIndex() - 1) instanceof ItemsListSeparator) {

                                list.getTable().setSelection(

                                        list.getTable().getSelectionIndex() - 1);

                            }

                            list.getTable().notifyListeners(SWT.Selection,

                                    new Event());

                        }

                    }

                    if (e.keyCode == SWT.ARROW_DOWN

                            && (e.stateMask & SWT.SHIFT) != 0

                            && (e.stateMask & SWT.CTRL) != 0) {

                        if (list

                                .getElementAt(list.getTable().getSelectionIndex() + 1) instanceof ItemsListSeparator) {

                            list.getTable().setSelection(

                                    list.getTable().getSelectionIndex() + 1);

                        }

                        list.getTable().notifyListeners(SWT.Selection, new Event());

                    }

                }

            });

            createExtendedContentArea(content);

            details = new DetailsContentViewer(content, SWT.BORDER | SWT.FLAT);

            details.setVisible(toggleStatusLineAction.isChecked());

            details.setContentProvider(new NullContentProvider());

            details.setLabelProvider(getDetailsLabelProvider());

            applyDialogFont(content);

            restoreDialog(getDialogSettings());

            if (initialPatternText != null) {

                pattern.setText(initialPatternText);

            }

            switch (selectionMode) {

            case CARET_BEGINNING:

                pattern.setSelection(0, 0);

                break;

            case FULL_SELECTION:

                pattern.setSelection(0, initialPatternText.length());

                break;

            }

            // apply filter even if pattern is empty (display history)

            applyFilter();

            return dialogArea;

        }

        /**

         * This method is a hook for subclasses to override default dialog behavior.

         * The <code>handleDoubleClick()</code> method handles double clicks on

         * the list of filtered elements.

         * <p>

         * Current implementation makes double-clicking on the list do the same as

         * pressing <code>OK</code> button on the dialog.

         */

        protected void handleDoubleClick() {

            okPressed();

        }

        /**

         * Refreshes the details field according to the current selection in the

         * items list.

         */

        private void refreshDetails() {

            StructuredSelection selection = getSelectedItems();

            switch (selection.size()) {

            case 0:

                details.setInput(null);

                break;

            case 1:

                details.setInput(selection.getFirstElement());

                break;

            default:

                details

                        .setInput(NLS

                                .bind(

                                        WorkbenchMessages.FilteredItemsSelectionDialog_nItemsSelected,

                                        new Integer(selection.size())));

                break;

            }

        }

        /**

         * Handle selection in the items list by updating labels of selected and

         * unselected items and refresh the details field using the selection.

         *

         * @param selection

         *            the new selection

         */

        protected void handleSelected(StructuredSelection selection) {

            IStatus status = new Status(IStatus.OK, PlatformUI.PLUGIN_ID,

                    IStatus.OK, EMPTY_STRING, null);

            Object[] lastSelection = currentSelection;

            currentSelection = selection.toArray();

            if (selection.size() == 0) {

                status = new Status(IStatus.ERROR, PlatformUI.PLUGIN_ID,

                        IStatus.ERROR, EMPTY_STRING, null);

                if (lastSelection != null

                        && getListSelectionLabelDecorator() != null) {

                    list.update(lastSelection, null);

                }

                currentSelection = null;

            } else {

                status = new Status(IStatus.ERROR, PlatformUI.PLUGIN_ID,

                        IStatus.ERROR, EMPTY_STRING, null);

                List items = selection.toList();

                Object item = null;

                IStatus tempStatus = null;

                for (Iterator it = items.iterator(); it.hasNext();) {

                    Object o = it.next();

                    if (o instanceof ItemsListSeparator) {

                        continue;

                    }

                    item = o;

                    tempStatus = validateItem(item);

                    if (tempStatus.isOK()) {

                        status = new Status(IStatus.OK, PlatformUI.PLUGIN_ID,

                                IStatus.OK, EMPTY_STRING, null);

                    } else {

                        status = tempStatus;

                        // if any selected element is not valid status is set to

                        // ERROR

                        break;

                    }

                }

                if (lastSelection != null

                        && getListSelectionLabelDecorator() != null) {

                    list.update(lastSelection, null);

                }

                if (getListSelectionLabelDecorator() != null) {

                    list.update(currentSelection, null);

                }

            }

            refreshDetails();

            updateStatus(status);

        }

        /*

         * (non-Javadoc)

         *

         * @see org.eclipse.jface.window.Dialog#getDialogBoundsSettings()

         */

        @Override

        protected IDialogSettings getDialogBoundsSettings() {

            IDialogSettings settings = getDialogSettings();

            IDialogSettings section = settings.getSection(DIALOG_BOUNDS_SETTINGS);

            if (section == null) {

                section = settings.addNewSection(DIALOG_BOUNDS_SETTINGS);

                section.put(DIALOG_HEIGHT, 500);

                section.put(DIALOG_WIDTH, 600);

            }

            return section;

        }

        /**

         * Returns the dialog settings. Returned object can't be null.

         *

         * @return return dialog settings for this dialog

         */

        protected abstract IDialogSettings getDialogSettings();

        /**

         * Refreshes the dialog - has to be called in UI thread.

         */

        public void refresh() {

            if (list != null && !list.getTable().isDisposed()) {

                List lastRefreshSelection = ((StructuredSelection) list

                        .getSelection()).toList();

                list.getTable().deselectAll();

                list.setItemCount(contentProvider.getNumberOfElements());

                list.refresh();

                if (list.getTable().getItemCount() > 0) {

                    // preserve previous selection

                    if (refreshWithLastSelection && lastRefreshSelection != null

                            && lastRefreshSelection.size() > 0) {

                        list.setSelection(new StructuredSelection(

                                lastRefreshSelection));

                    } else {

                        refreshWithLastSelection = true;

                        list.getTable().setSelection(0);

                        list.getTable().notifyListeners(SWT.Selection, new Event());

                    }

                } else {

                    list.setSelection(StructuredSelection.EMPTY);

                }

            }

            scheduleProgressMessageRefresh();

        }

        /**

         * Updates the progress label.

         *

         * @deprecated

         */

        @Deprecated

        public void updateProgressLabel() {

            scheduleProgressMessageRefresh();

        }

        /**

         * Notifies the content provider - fires filtering of content provider

         * elements. During the filtering, a separator between history and workspace

         * matches is added.

         * <p>

         * This is a long running operation and should be called in a job.

         *

         * @param checkDuplicates

         *            <code>true</code> if data concerning elements duplication

         *            should be computed - it takes much more time than the standard

         *            filtering

         * @param monitor

         *            a progress monitor or <code>null</code> if no monitor is

         *            available

         */

        public void reloadCache(boolean checkDuplicates, IProgressMonitor monitor) {

            if (list != null && !list.getTable().isDisposed()

                    && contentProvider != null) {

                contentProvider.reloadCache(checkDuplicates, monitor);

            }

        }

        /**

         * Schedule refresh job.

         */

        public void scheduleRefresh() {

            refreshCacheJob.cancelAll();

            refreshCacheJob.schedule();

        }

        /**

         * Schedules progress message refresh.

         */

        public void scheduleProgressMessageRefresh() {

            if (filterJob.getState() != Job.RUNNING

                    && refreshProgressMessageJob.getState() != Job.RUNNING) {

                refreshProgressMessageJob.scheduleProgressRefresh(null);

            }

        }

        /*

         * (non-Javadoc)

         *

         * @see org.eclipse.ui.dialogs.SelectionStatusDialog#computeResult()

         */

        @Override

        protected void computeResult() {

            List selectedElements = ((StructuredSelection) list.getSelection())

                    .toList();

            List objectsToReturn = new ArrayList();

            Object item = null;

            for (Iterator it = selectedElements.iterator(); it.hasNext();) {

                item = it.next();

                if (!(item instanceof ItemsListSeparator)) {

                    accessedHistoryItem(item);

                    objectsToReturn.add(item);

                }

            }

            setResult(objectsToReturn);

        }

        /*

         * @see org.eclipse.ui.dialogs.SelectionStatusDialog#updateStatus(org.eclipse.core.runtime.IStatus)

         */

        @Override

        protected void updateStatus(IStatus status) {

            this.status = status;

            super.updateStatus(status);

        }

        /*

         * @see Dialog#okPressed()

         */

        @Override

        protected void okPressed() {

            if (status != null

                    && (status.isOK() || status.getCode() == IStatus.INFO)) {

                super.okPressed();

            }

        }

        /**

         * Sets the initial pattern used by the filter. This text is copied into the

         * selection input on the dialog. A full selection is used in the pattern

         * input field.

         *

         * @param text

         *            initial pattern for the filter

         * @see FilteredItemsSelectionDialog#FULL_SELECTION

         */

        public void setInitialPattern(String text) {

            setInitialPattern(text, FULL_SELECTION);

        }

        /**

         * Sets the initial pattern used by the filter. This text is copied into the

         * selection input on the dialog. The <code>selectionMode</code> is used

         * to choose selection type for the input field.

         *

         * @param text

         *            initial pattern for the filter

         * @param selectionMode

         *            one of: {@link FilteredItemsSelectionDialog#NONE},

         *            {@link FilteredItemsSelectionDialog#CARET_BEGINNING},

         *            {@link FilteredItemsSelectionDialog#FULL_SELECTION}

         */

        public void setInitialPattern(String text, int selectionMode) {

            this.initialPatternText = text;

            this.selectionMode = selectionMode;

        }

        /**

         * Gets initial pattern.

         *

         * @return initial pattern, or <code>null</code> if initial pattern is not

         *         set

         */

        protected String getInitialPattern() {

            return this.initialPatternText;

        }

        /**

         * Returns the current selection.

         *

         * @return the current selection

         */

        protected StructuredSelection getSelectedItems() {

            StructuredSelection selection = (StructuredSelection) list

                    .getSelection();

            List selectedItems = selection.toList();

            Object itemToRemove = null;

            for (Iterator it = selection.iterator(); it.hasNext();) {

                Object item = it.next();

                if (item instanceof ItemsListSeparator) {

                    itemToRemove = item;

                    break;

                }

            }

            if (itemToRemove == null) {

                return new StructuredSelection(selectedItems);

            }

            // Create a new selection without the collision

            List newItems = new ArrayList(selectedItems);

            newItems.remove(itemToRemove);

            return new StructuredSelection(newItems);

        }

        /**

         * Validates the item. When items on the items list are selected or

         * deselected, it validates each item in the selection and the dialog status

         * depends on all validations.

         *

         * @param item

         *            an item to be checked

         * @return status of the dialog to be set

         */

        protected abstract IStatus validateItem(Object item);

        /**

         * Creates an instance of a filter.

         *

         * @return a filter for items on the items list. Can be <code>null</code>,

         *         no filtering will be applied then, causing no item to be shown in

         *         the list.

         */

        protected abstract ItemsFilter createFilter();

        /**

         * Applies the filter created by <code>createFilter()</code> method to the

         * items list. When new filter is different than previous one it will cause

         * refiltering.

         */

        protected void applyFilter() {

            ItemsFilter newFilter = createFilter();

            // don't apply filtering for patterns which mean the same, for example:

            // *a**b and ***a*b

            if (filter != null && filter.equalsFilter(newFilter)) {

                return;

            }

            filterHistoryJob.cancel();

            filterJob.cancel();

            this.filter = newFilter;

            if (this.filter != null) {

                filterHistoryJob.schedule();

            }

        }

        /**

         * Returns comparator to sort items inside content provider. Returned object

         * will be probably created as an anonymous class. Parameters passed to the

         * <code>compare(java.lang.Object, java.lang.Object)</code> are going to

         * be the same type as the one used in the content provider.

         *

         * @return comparator to sort items content provider

         */

        protected abstract Comparator getItemsComparator();

        /**

         * Fills the content provider with matching items.

         *

         * @param contentProvider

         *            collector to add items to.

         *            {@link FilteredItemsSelectionDialog.AbstractContentProvider#add(Object, FilteredItemsSelectionDialog.ItemsFilter)}

         *            only adds items that pass the given <code>itemsFilter</code>.

         * @param itemsFilter

         *            the items filter

         * @param progressMonitor

         *            must be used to report search progress. The state of this

         *            progress monitor reflects the state of the filtering process.

         * @throws CoreException

         */

        protected abstract void fillContentProvider(

                AbstractContentProvider contentProvider, ItemsFilter itemsFilter,

                IProgressMonitor progressMonitor) throws CoreException;

        /**

         * Removes selected items from history.

         *

         * @param items

         *            items to be removed

         */

        private void removeSelectedItems(List items) {

            for (Iterator iter = items.iterator(); iter.hasNext();) {

                Object item = iter.next();

                removeHistoryItem(item);

            }

            refreshWithLastSelection = false;

            contentProvider.refresh();

        }

        /**

         * Removes an item from history.

         *

         * @param item

         *            an item to remove

         * @return removed item

         */

        protected Object removeHistoryItem(Object item) {

            return contentProvider.removeHistoryElement(item);

        }

        /**

         * Adds item to history.

         *

         * @param item

         *            the item to be added

         */

        protected void accessedHistoryItem(Object item) {

            contentProvider.addHistoryElement(item);

        }

        /**

         * Returns a history comparator.

         *

         * @return decorated comparator

         */

        private Comparator getHistoryComparator() {

            return new HistoryComparator();

        }

        /**

         * Returns the history of selected elements.

         *

         * @return history of selected elements, or <code>null</code> if it is not

         *         set

         */

        protected SelectionHistory getSelectionHistory() {

            return this.contentProvider.getSelectionHistory();

        }

        /**

         * Sets new history.

         *

         * @param selectionHistory

         *            the history

         */

        protected void setSelectionHistory(SelectionHistory selectionHistory) {

            if (this.contentProvider != null) {

                this.contentProvider.setSelectionHistory(selectionHistory);

            }

        }

        /**

         * Indicates whether the given item is a history item.

         *

         * @param item

         *            the item to be investigated

         * @return <code>true</code> if the given item exists in history,

         *         <code>false</code> otherwise

         */

        public boolean isHistoryElement(Object item) {

            return this.contentProvider.isHistoryElement(item);

        }

        /**

         * Indicates whether the given item is a duplicate.

         *

         * @param item

         *            the item to be investigated

         * @return <code>true</code> if the item is duplicate, <code>false</code>

         *         otherwise

         */

        public boolean isDuplicateElement(Object item) {

            return this.contentProvider.isDuplicateElement(item);

        }

        /**

         * Sets separator label

         *

         * @param separatorLabel

         *            the label showed on separator

         */

        public void setSeparatorLabel(String separatorLabel) {

            this.itemsListSeparator = new ItemsListSeparator(separatorLabel);

        }

        /**

         * Returns name for then given object.

         *

         * @param item

         *            an object from the content provider. Subclasses should pay

         *            attention to the passed argument. They should either only pass

         *            objects of a known type (one used in content provider) or make

         *            sure that passed parameter is the expected one (by type

         *            checking like <code>instanceof</code> inside the method).

         * @return name of the given item

         */

        public abstract String getElementName(Object item);

        private class ToggleStatusLineAction extends Action {

            /**

             * Creates a new instance of the class.

             */

            public ToggleStatusLineAction() {

                super(

                        WorkbenchMessages.FilteredItemsSelectionDialog_toggleStatusAction,

                        IAction.AS_CHECK_BOX);

            }

            @Override

            public void run() {

                details.setVisible(isChecked());

            }

        }

        /**

         * Only refreshes UI on the basis of an already sorted and filtered set of

         * items.

         * <p>

         * Standard invocation scenario:

         * <ol>

         * <li>filtering job (<code>FilterJob</code> class extending

         * <code>Job</code> class)</li>

         * <li>cache refresh without checking for duplicates (<code>RefreshCacheJob</code>

         * class extending <code>Job</code> class)</li>

         * <li>UI refresh (<code>RefreshJob</code> class extending

         * <code>UIJob</code> class)</li>

         * <li>cache refresh with checking for duplicates (<cod>CacheRefreshJob</code>

         * class extending <code>Job</code> class)</li>

         * <li>UI refresh (<code>RefreshJob</code> class extending <code>UIJob</code>

         * class)</li>

         * </ol>

         * The scenario is rather complicated, but it had to be applied, because:

         * <ul>

         * <li> refreshing cache is rather a long action and cannot be run in the UI -

         * cannot be run in a UIJob</li>

         * <li> refreshing cache checking for duplicates is twice as long as

         * refreshing cache without checking for duplicates; results of the search

         * could be displayed earlier</li>

         * <li> refreshing the UI have to be run in a UIJob</li>

         * </ul>

         *

         * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.FilterJob

         * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.RefreshJob

         * @see org.eclipse.ui.dialogs.FilteredItemsSelectionDialog.RefreshCacheJob

         */

        private class RefreshJob extends UIJob {

            /**

             * Creates a new instance of the class.

             */

            public RefreshJob() {

                super(CdmFilteredItemsSelectionDialog.this.getParentShell()

                        .getDisplay(),

                        WorkbenchMessages.FilteredItemsSelectionDialog_refreshJob);

                setSystem(true);

            }

            /*

             * (non-Javadoc)

             *

             * @see org.eclipse.ui.progress.UIJob#runInUIThread(org.eclipse.core.runtime.IProgressMonitor)

             */

            @Override

            public IStatus runInUIThread(IProgressMonitor monitor) {

                if (monitor.isCanceled()) {

                    return new Status(IStatus.OK, WorkbenchPlugin.PI_WORKBENCH,

                            IStatus.OK, EMPTY_STRING, null);

                }

                if (CdmFilteredItemsSelectionDialog.this != null) {

                    CdmFilteredItemsSelectionDialog.this.refresh();

                }

                return new Status(IStatus.OK, PlatformUI.PLUGIN_ID, IStatus.OK,

                        EMPTY_STRING, null);

            }

        }

        /**

         * Refreshes the progress message cyclically with 500 milliseconds delay.

         * <code>RefreshProgressMessageJob</code> is strictly connected with

         * <code>GranualProgressMonitor</code> and use it to to get progress

         * message and to decide about break of cyclical refresh.

         */

        private class RefreshProgressMessageJob extends UIJob {

            private GranualProgressMonitor progressMonitor;

            /**

             * Creates a new instance of the class.

             */

            public RefreshProgressMessageJob() {

                super(

                        CdmFilteredItemsSelectionDialog.this.getParentShell()

                                .getDisplay(),

                        WorkbenchMessages.FilteredItemsSelectionDialog_progressRefreshJob);

                setSystem(true);

            }

            /*

             * (non-Javadoc)

             *

             * @see org.eclipse.ui.progress.UIJob#runInUIThread(org.eclipse.core.runtime.IProgressMonitor)

             */

            @Override

            public IStatus runInUIThread(IProgressMonitor monitor) {

                if (!progressLabel.isDisposed()) {

                    progressLabel.setText(progressMonitor != null ? progressMonitor

                            .getMessage() : EMPTY_STRING);

                }

                if (progressMonitor == null || progressMonitor.isDone()) {

                    return new Status(IStatus.CANCEL, PlatformUI.PLUGIN_ID,

                            IStatus.CANCEL, EMPTY_STRING, null);

                }

                // Schedule cyclical with 500 milliseconds delay

                schedule(500);

                return new Status(IStatus.OK, PlatformUI.PLUGIN_ID, IStatus.OK,

                        EMPTY_STRING, null);

            }

            /**

             * Schedule progress refresh job.

             *

             * @param progressMonitor

             *            used during refresh progress label

             */

            public void scheduleProgressRefresh(

                    GranualProgressMonitor progressMonitor) {