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();