/*******************************************************************************
 * Copyright (c) 2000, 2008 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Guy Gurfinkel, guy.g@zend.com - [content assist][api] provide better access to ContentAssistant - https://bugs.eclipse.org/bugs/show_bug.cgi?id=169954
 *     Anton Leherbauer (Wind River Systems) - [content assist][api] ContentAssistEvent should contain information about auto activation - https://bugs.eclipse.org/bugs/show_bug.cgi?id=193728
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwtx.jface.text.contentassist.ContentAssistant;

import dwtx.jface.text.contentassist.ContentAssistEvent; // packageimport
import dwtx.jface.text.contentassist.Helper; // packageimport
import dwtx.jface.text.contentassist.PopupCloser; // packageimport
import dwtx.jface.text.contentassist.IContentAssistant; // packageimport
import dwtx.jface.text.contentassist.CompletionProposal; // packageimport
import dwtx.jface.text.contentassist.ICompletionProposalExtension5; // packageimport
import dwtx.jface.text.contentassist.IContextInformationValidator; // packageimport
import dwtx.jface.text.contentassist.IContentAssistListener; // packageimport
import dwtx.jface.text.contentassist.ICompletionProposalExtension6; // packageimport
import dwtx.jface.text.contentassist.ICompletionListener; // packageimport
import dwtx.jface.text.contentassist.ICompletionProposalExtension2; // packageimport
import dwtx.jface.text.contentassist.IContentAssistantExtension4; // packageimport
import dwtx.jface.text.contentassist.ContextInformation; // packageimport
import dwtx.jface.text.contentassist.ICompletionProposalExtension3; // packageimport
import dwtx.jface.text.contentassist.ContextInformationValidator; // packageimport
import dwtx.jface.text.contentassist.ICompletionProposal; // packageimport
import dwtx.jface.text.contentassist.IContentAssistProcessor; // packageimport
import dwtx.jface.text.contentassist.AdditionalInfoController; // packageimport
import dwtx.jface.text.contentassist.IContextInformationPresenter; // packageimport
import dwtx.jface.text.contentassist.ICompletionProposalExtension4; // packageimport
import dwtx.jface.text.contentassist.ICompletionListenerExtension; // packageimport
import dwtx.jface.text.contentassist.ContextInformationPopup; // packageimport
import dwtx.jface.text.contentassist.IContextInformationExtension; // packageimport
import dwtx.jface.text.contentassist.IContentAssistantExtension2; // packageimport
import dwtx.jface.text.contentassist.ContentAssistSubjectControlAdapter; // packageimport
import dwtx.jface.text.contentassist.CompletionProposalPopup; // packageimport
import dwtx.jface.text.contentassist.ICompletionProposalExtension; // packageimport
import dwtx.jface.text.contentassist.IContextInformation; // packageimport
import dwtx.jface.text.contentassist.IContentAssistantExtension3; // packageimport
import dwtx.jface.text.contentassist.IContentAssistantExtension; // packageimport
import dwtx.jface.text.contentassist.JFaceTextMessages; // packageimport

import dwt.dwthelper.utils;
import dwtx.dwtxhelper.Collection;
import dwtx.dwtxhelper.JThread;
import tango.core.sync.Mutex;
import tango.core.sync.Condition;

import dwt.DWT;
import dwt.DWTError;
import dwt.custom.VerifyKeyListener;
import dwt.events.ControlEvent;
import dwt.events.ControlListener;
import dwt.events.DisposeEvent;
import dwt.events.DisposeListener;
import dwt.events.FocusEvent;
import dwt.events.FocusListener;
import dwt.events.KeyAdapter;
import dwt.events.KeyEvent;
import dwt.events.KeyListener;
import dwt.events.MouseEvent;
import dwt.events.MouseListener;
import dwt.events.TraverseEvent;
import dwt.events.TraverseListener;
import dwt.events.VerifyEvent;
import dwt.graphics.Color;
import dwt.graphics.Point;
import dwt.graphics.Rectangle;
import dwt.widgets.Control;
import dwt.widgets.Display;
import dwt.widgets.Event;
import dwt.widgets.Listener;
import dwt.widgets.Monitor;
import dwt.widgets.Shell;
import dwt.widgets.Widget;
import dwtx.core.commands.IHandler;
import dwtx.core.runtime.Assert;
import dwtx.core.runtime.ListenerList;
import dwtx.jface.bindings.keys.KeySequence;
import dwtx.jface.contentassist.IContentAssistSubjectControl;
import dwtx.jface.contentassist.ISubjectControlContentAssistProcessor;
import dwtx.jface.dialogs.IDialogSettings;
import dwtx.jface.preference.JFacePreferences;
import dwtx.jface.text.BadLocationException;
import dwtx.jface.text.IDocument;
import dwtx.jface.text.IDocumentExtension3;
import dwtx.jface.text.IEventConsumer;
import dwtx.jface.text.IInformationControlCreator;
import dwtx.jface.text.ITextViewer;
import dwtx.jface.text.IViewportListener;
import dwtx.jface.text.IWidgetTokenKeeper;
import dwtx.jface.text.IWidgetTokenKeeperExtension;
import dwtx.jface.text.IWidgetTokenOwner;
import dwtx.jface.text.IWidgetTokenOwnerExtension;
import dwtx.jface.text.TextUtilities;
import dwtx.jface.util.Geometry;


/**
 * The standard implementation of the <code>IContentAssistant</code> interface. Usually, clients
 * instantiate this class and configure it before using it.
 */
public class ContentAssistant : IContentAssistant, IContentAssistantExtension, IContentAssistantExtension2, IContentAssistantExtension3, IContentAssistantExtension4, IWidgetTokenKeeper, IWidgetTokenKeeperExtension {



    /**
     * Content assist command identifier for 'select next proposal'.
     *
     * @since 3.4
     */
    public static const String SELECT_NEXT_PROPOSAL_COMMAND_ID= "dwtx.ui.edit.text.contentAssist.selectNextProposal"; //$NON-NLS-1$
    /**
     * Content assist command identifier for 'select previous proposal'.
     *
     * @since 3.4
     */
    public static const String SELECT_PREVIOUS_PROPOSAL_COMMAND_ID= "dwtx.ui.edit.text.contentAssist.selectPreviousProposal"; //$NON-NLS-1$


    /**
     * A generic closer class used to monitor various interface events in order to determine whether
     * content-assist should be terminated and all associated windows closed.
     */
    class Closer : ControlListener, MouseListener, FocusListener, DisposeListener, IViewportListener {

        /** The shell that a <code>ControlListener</code> is registered with. */
        private Shell fShell;
        /**
         * The control that a <code>MouseListener</code>, a<code>FocusListener</code> and a
         * <code>DisposeListener</code> are registered with.
         */
        private Control fControl;

        /**
         * Installs this closer on it's viewer's text widget.
         */
        protected void install() {
            Control control= fContentAssistSubjectControlAdapter.getControl();
            fControl= control;
            if (Helper.okToUse(control)) {

                Shell shell= control.getShell();
                fShell= shell;
                shell.addControlListener(this);

                control.addMouseListener(this);
                control.addFocusListener(this);

                /*
                 * 1GGYYWK: ITPJUI:ALL - Dismissing editor with code assist up causes lots of
                 * Internal Errors
                 */
                control.addDisposeListener(this);
            }
            if (fViewer !is null)
                fViewer.addViewportListener(this);
        }

        /**
         * Uninstalls this closer from the viewer's text widget.
         */
        protected void uninstall() {
            Control shell= fShell;
            fShell= null;
            if (Helper.okToUse(shell))
                shell.removeControlListener(this);

            Control control= fControl;
            fControl= null;
            if (Helper.okToUse(control)) {

                control.removeMouseListener(this);
                control.removeFocusListener(this);

                /*
                 * 1GGYYWK: ITPJUI:ALL - Dismissing editor with code assist up causes lots of
                 * Internal Errors
                 */
                control.removeDisposeListener(this);
            }

            if (fViewer !is null)
                fViewer.removeViewportListener(this);
        }

        /*
         * @see ControlListener#controlResized(ControlEvent)
         */
        public void controlResized(ControlEvent e) {
            hide();
        }

        /*
         * @see ControlListener#controlMoved(ControlEvent)
         */
        public void controlMoved(ControlEvent e) {
            hide();
        }

        /*
         * @see MouseListener#mouseDown(MouseEvent)
         */
        public void mouseDown(MouseEvent e) {
            hide();
        }

        /*
         * @see MouseListener#mouseUp(MouseEvent)
         */
        public void mouseUp(MouseEvent e) {
        }

        /*
         * @see MouseListener#mouseDoubleClick(MouseEvent)
         */
        public void mouseDoubleClick(MouseEvent e) {
            hide();
        }

        /*
         * @see FocusListener#focusGained(FocusEvent)
         */
        public void focusGained(FocusEvent e) {
        }

        /*
         * @see FocusListener#focusLost(FocusEvent)
         */
        public void focusLost(FocusEvent e) {
            Control control= fControl;
            if (Helper.okToUse(control)) {
                Display d= control.getDisplay();
                if (d !is null) {
                    d.asyncExec(new class()  Runnable {
                        public void run() {
                            if (!fProposalPopup.hasFocus() && (fContextInfoPopup is null || !fContextInfoPopup.hasFocus()))
                                hide();
                        }
                    });
                }
            }
        }

        /*
         * @seeDisposeListener#widgetDisposed(DisposeEvent)
         */
        public void widgetDisposed(DisposeEvent e) {
            /*
             * 1GGYYWK: ITPJUI:ALL - Dismissing editor with code assist up causes lots of Internal
             * Errors
             */
            hide();
        }

        /*
         * @see IViewportListener#viewportChanged(int)
         */
        public void viewportChanged(int topIndex) {
            hide();
        }
    }

    /**
     * An implementation of <code>IContentAssistListener</code>, this class is used to monitor
     * key events in support of automatic activation of the content assistant. If enabled, the
     * implementation utilizes a thread to watch for input characters matching the activation
     * characters specified by the content assist processor, and if detected, will wait the
     * indicated delay interval before activating the content assistant.
     *
     * @since 3.4 protected, was added in 2.1 as private class
     */
    protected class AutoAssistListener : KeyAdapter , KeyListener, Runnable, VerifyKeyListener {

        // DWT intf impl
        public void keyReleased(KeyEvent e) {
            super.keyReleased(e);
        }

        private JThread fThread;
        private bool fIsReset= false;
        private Mutex fMutex;
        private Condition fMutex_cond;
        private int fShowStyle;

        private const static int SHOW_PROPOSALS= 1;
        private const static int SHOW_CONTEXT_INFO= 2;

        protected this() {
            fMutex = new Mutex();
            fMutex_cond = new Condition(fMutex);
        }

        protected void start(int showStyle) {
            fShowStyle= showStyle;
            fThread= new JThread(this);
            fThread.setName( JFaceTextMessages.getString("ContentAssistant.assist_delay_timer_name")); //$NON-NLS-1$
            fThread.start();
        }

        public override void run() {
            try {
                while (true) {
                    synchronized (fMutex) {
                        if (fAutoActivationDelay !is 0)
                            fMutex_cond.wait(fAutoActivationDelay);
                        if (fIsReset) {
                            fIsReset= false;
                            continue;
                        }
                    }
                    showAssist(fShowStyle);
                    break;
                }
            } catch (InterruptedException e) {
            }
            fThread= null;
        }

        protected void reset(int showStyle) {
            synchronized (fMutex) {
                fShowStyle= showStyle;
                fIsReset= true;
                fMutex_cond.notifyAll();
            }
        }

        protected void stop() {
            JThread threadToStop= fThread;
            if (threadToStop !is null && threadToStop.isAlive())
                threadToStop.interrupt();
        }

        private bool contains(char[] characters, char character) {
            if (characters !is null) {
                for (int i= 0; i < characters.length; i++) {
                    if (character is characters[i])
                        return true;
                }
            }
            return false;
        }

        public void keyPressed(KeyEvent e) {
            // Only act on typed characters and ignore modifier-only events
            if (e.character is 0 && (e.keyCode & DWT.KEYCODE_BIT) is 0)
                return;

            if (e.character !is 0 && (e.stateMask is DWT.ALT))
                return;

            // Only act on characters that are trigger candidates. This
            // avoids computing the model selection on every keystroke
            if (computeAllAutoActivationTriggers().indexOf(e.character) < 0) {
                stop();
                return;
            }

            int showStyle;
            int pos= fContentAssistSubjectControlAdapter.getSelectedRange().x;
            char[] activation;

            activation= fContentAssistSubjectControlAdapter.getCompletionProposalAutoActivationCharacters(this.outer, pos);

            if (contains(activation, e.character) && !isProposalPopupActive())
                showStyle= SHOW_PROPOSALS;
            else {
                activation= fContentAssistSubjectControlAdapter.getContextInformationAutoActivationCharacters(this.outer, pos);
                if (contains(activation, e.character) && !isContextInfoPopupActive())
                    showStyle= SHOW_CONTEXT_INFO;
                else {
                    stop();
                    return;
                }
            }

            if (fThread !is null && fThread.isAlive())
                reset(showStyle);
            else
                start(showStyle);
        }

        /*
         * @see dwt.custom.VerifyKeyListener#verifyKey(dwt.events.VerifyEvent)
         */
        public void verifyKey(VerifyEvent event) {
            keyPressed(event);
        }

        protected void showAssist(int showStyle) {
            final Control control= fContentAssistSubjectControlAdapter.getControl();
            if (control is null)
                return;

            final Display d= control.getDisplay();
            if (d is null)
                return;

            try {
                d.syncExec(new class()  Runnable {
                    public void run() {
                        if (isProposalPopupActive())
                            return;

                        if (control.isDisposed() || !control.isFocusControl())
                            return;

                        if (showStyle is SHOW_PROPOSALS) {
                            if (!prepareToShowCompletions(true))
                                return;
                            fProposalPopup.showProposals(true);
                            fLastAutoActivation= System.currentTimeMillis();
                        } else if (showStyle is SHOW_CONTEXT_INFO && fContextInfoPopup !is null) {
                            promoteKeyListener();
                            fContextInfoPopup.showContextProposals(true);
                        }
                    }
                });
            } catch (DWTError e) {
            }
        }
    }

    /**
     * The layout manager layouts the various windows associated with the content assistant based on
     * the settings of the content assistant.
     */
    class LayoutManager : Listener {

        // Presentation types.
        /** The presentation type for the proposal selection popup. */
        public const static int LAYOUT_PROPOSAL_SELECTOR= 0;
        /** The presentation type for the context selection popup. */
        public const static int LAYOUT_CONTEXT_SELECTOR= 1;
        /** The presentation type for the context information hover . */
        public const static int LAYOUT_CONTEXT_INFO_POPUP= 2;

        int fContextType= LAYOUT_CONTEXT_SELECTOR;
        Shell[] fShells;
        Object[] fPopups;

        this(){
            fShells= new Shell[3];
            fPopups= new Object[3];
        }

        protected void add(Object popup, Shell shell, int type, int offset) {
            Assert.isNotNull(popup);
            Assert.isTrue(shell !is null && !shell.isDisposed());
            checkType(type);

            if (fShells[type] !is shell) {
                if (fShells[type] !is null)
                    fShells[type].removeListener(DWT.Dispose, this);
                shell.addListener(DWT.Dispose, this);
                fShells[type]= shell;
            }

            fPopups[type]= popup;
            if (type is LAYOUT_CONTEXT_SELECTOR || type is LAYOUT_CONTEXT_INFO_POPUP)
                fContextType= type;

            layout(type, offset);
            adjustListeners(type);
        }

        protected void checkType(int type) {
            Assert.isTrue(type is LAYOUT_PROPOSAL_SELECTOR ||
                type is LAYOUT_CONTEXT_SELECTOR || type is LAYOUT_CONTEXT_INFO_POPUP);
        }

        public void handleEvent(Event event) {
            Widget source= event.widget;
            source.removeListener(DWT.Dispose, this);

            int type= getShellType(source);
            checkType(type);
            fShells[type]= null;

            switch (type) {
                case LAYOUT_PROPOSAL_SELECTOR:
                    if (fContextType is LAYOUT_CONTEXT_SELECTOR &&
                            Helper.okToUse(fShells[LAYOUT_CONTEXT_SELECTOR])) {
                        // Restore event notification to the tip popup.
                        addContentAssistListener(cast(IContentAssistListener) fPopups[LAYOUT_CONTEXT_SELECTOR], CONTEXT_SELECTOR);
                    }
                    break;

                case LAYOUT_CONTEXT_SELECTOR:
                    if (Helper.okToUse(fShells[LAYOUT_PROPOSAL_SELECTOR])) {
                        if (fProposalPopupOrientation is PROPOSAL_STACKED)
                            layout(LAYOUT_PROPOSAL_SELECTOR, getSelectionOffset());
                        // Restore event notification to the proposal popup.
                        addContentAssistListener(cast(IContentAssistListener) fPopups[LAYOUT_PROPOSAL_SELECTOR], PROPOSAL_SELECTOR);
                    }
                    fContextType= LAYOUT_CONTEXT_INFO_POPUP;
                    break;

                case LAYOUT_CONTEXT_INFO_POPUP:
                    if (Helper.okToUse(fShells[LAYOUT_PROPOSAL_SELECTOR])) {
                        if (fContextInfoPopupOrientation is CONTEXT_INFO_BELOW)
                            layout(LAYOUT_PROPOSAL_SELECTOR, getSelectionOffset());
                    }
                    fContextType= LAYOUT_CONTEXT_SELECTOR;
                    break;
                default:
            }
        }

        protected int getShellType(Widget shell) {
            for (int i= 0; i < fShells.length; i++) {
                if (fShells[i] is shell)
                    return i;
            }
            return -1;
        }

        /**
         * Layouts the popup defined by <code>type</code> at the given widget offset.
         *
         * @param type the kind of popup to layout
         * @param offset the widget offset
         */
        protected void layout(int type, int offset) {
            switch (type) {
                case LAYOUT_PROPOSAL_SELECTOR:
                    layoutProposalSelector(offset);
                    break;
                case LAYOUT_CONTEXT_SELECTOR:
                    layoutContextSelector(offset);
                    break;
                case LAYOUT_CONTEXT_INFO_POPUP:
                    layoutContextInfoPopup(offset);
                    break;
                default:
            }
        }

        protected void layoutProposalSelector(int offset) {
            if (fContextType is LAYOUT_CONTEXT_INFO_POPUP &&
                    fContextInfoPopupOrientation is CONTEXT_INFO_BELOW &&
                    Helper.okToUse(fShells[LAYOUT_CONTEXT_INFO_POPUP])) {
                // Stack proposal selector beneath the tip box.
                Shell shell= fShells[LAYOUT_PROPOSAL_SELECTOR];
                Shell parent= fShells[LAYOUT_CONTEXT_INFO_POPUP];
                shell.setLocation(getStackedLocation(shell, parent));
            } else if (fContextType !is LAYOUT_CONTEXT_SELECTOR ||
                        !Helper.okToUse(fShells[LAYOUT_CONTEXT_SELECTOR])) {
                // There are no other presentations to be concerned with,
                // so place the proposal selector beneath the cursor line.
                Shell shell= fShells[LAYOUT_PROPOSAL_SELECTOR];
                CompletionProposalPopup popup= cast(CompletionProposalPopup) fPopups[LAYOUT_PROPOSAL_SELECTOR];
                shell.setBounds(computeBoundsBelowAbove(shell, shell.getSize(), offset, popup));
            } else {
                CompletionProposalPopup popup= (cast(CompletionProposalPopup) fPopups[LAYOUT_PROPOSAL_SELECTOR]);
                switch (fProposalPopupOrientation) {
                    case PROPOSAL_REMOVE: {
                        // Remove the tip selector and place the
                        // proposal selector beneath the cursor line.
                        fShells[LAYOUT_CONTEXT_SELECTOR].dispose();
                        Shell shell= fShells[LAYOUT_PROPOSAL_SELECTOR];
                        shell.setBounds(computeBoundsBelowAbove(shell, shell.getSize(), offset, popup));
                        break;
                    }
                    case PROPOSAL_OVERLAY: {
                        // Overlay the tip selector with the proposal selector.
                        Shell shell= fShells[LAYOUT_PROPOSAL_SELECTOR];
                        shell.setBounds(computeBoundsBelowAbove(shell, shell.getSize(), offset, popup));
                        break;
                    }
                    case PROPOSAL_STACKED: {
                        // Stack the proposal selector beneath the tip selector.
                        Shell shell= fShells[LAYOUT_PROPOSAL_SELECTOR];
                        Shell parent= fShells[LAYOUT_CONTEXT_SELECTOR];
                        shell.setLocation(getStackedLocation(shell, parent));
                        break;
                    }
                    default:
                }
            }
        }

        protected void layoutContextSelector(int offset) {
            // Always place the context selector beneath the cursor line.
            Shell shell= fShells[LAYOUT_CONTEXT_SELECTOR];
            shell.setBounds(computeBoundsBelowAbove(shell, shell.getSize(), offset, null));

            if (Helper.okToUse(fShells[LAYOUT_PROPOSAL_SELECTOR])) {
                switch (fProposalPopupOrientation) {
                    case PROPOSAL_REMOVE:
                        // Remove the proposal selector.
                        fShells[LAYOUT_PROPOSAL_SELECTOR].dispose();
                        break;

                    case PROPOSAL_OVERLAY:
                        // The proposal selector has been overlaid by the tip selector.
                        break;

                    case PROPOSAL_STACKED: {
                        // Stack the proposal selector beneath the tip selector.
                        shell= fShells[LAYOUT_PROPOSAL_SELECTOR];
                        Shell parent= fShells[LAYOUT_CONTEXT_SELECTOR];
                        shell.setLocation(getStackedLocation(shell, parent));
                        break;
                    }
                    default:
                }
            }
        }

        protected void layoutContextInfoPopup(int offset) {
            switch (fContextInfoPopupOrientation) {
                case CONTEXT_INFO_ABOVE: {
                    // Place the popup above the cursor line.
                    Shell shell= fShells[LAYOUT_CONTEXT_INFO_POPUP];
                    shell.setBounds(computeBoundsAboveBelow(shell, shell.getSize(), offset));
                    break;
                }
                case CONTEXT_INFO_BELOW: {
                    // Place the popup beneath the cursor line.
                    Shell parent= fShells[LAYOUT_CONTEXT_INFO_POPUP];
                    parent.setBounds(computeBoundsBelowAbove(parent, parent.getSize(), offset, null));
                    if (Helper.okToUse(fShells[LAYOUT_PROPOSAL_SELECTOR])) {
                        // Stack the proposal selector beneath the context info popup.
                        Shell shell= fShells[LAYOUT_PROPOSAL_SELECTOR];
                        shell.setLocation(getStackedLocation(shell, parent));
                    }
                    break;
                }
                default:
            }
        }

        /**
         * Moves <code>point</code> such that <code>rectangle</code> does not bleed outside of
         * <code>bounds</code>. All coordinates must have the same reference.
         *
         * @param point the point to move if needed
         * @param shellSize the size of the shell that may be moved
         * @param bounds the bounds
         * @since 3.3
         */
        protected void constrainLocation(Point point, Point shellSize, Rectangle bounds) {
            if (point.x + shellSize.x > bounds.x + bounds.width)
                point.x= bounds.x + bounds.width - shellSize.x;

            if (point.x < bounds.x)
                point.x= bounds.x;

            if (point.y + shellSize.y > bounds.y + bounds.height)
                point.y= bounds.y + bounds.height - shellSize.y;

            if (point.y < bounds.y)
                point.y= bounds.y;
        }

        protected Rectangle constrainHorizontally(Rectangle rect, Rectangle bounds) {
            // clip width
            if (rect.width > bounds.width)
                rect.width= bounds.width;

            if (rect.x + rect.width > bounds.x + bounds.width)
                rect.x= bounds.x + bounds.width - rect.width;
            if (rect.x < bounds.x)
                rect.x= bounds.x;

            return rect;
        }

        /**
         * Returns the display bounds for <code>shell</code> such that it appears right above
         * <code>offset</code>, or below it if above is not suitable. The returned bounds lie
         * within the monitor at the caret location and never overlap with the caret line.
         *
         * @param shell the shell to compute the placement for
         * @param preferred the preferred size for <code>shell</code>
         * @param offset the caret offset in the subject control
         * @return the point right above <code>offset</code> in display coordinates
         * @since 3.3
         */
        protected Rectangle computeBoundsAboveBelow(Shell shell, Point preferred, int offset) {
            Control subjectControl= fContentAssistSubjectControlAdapter.getControl();
            Display display= subjectControl.getDisplay();
            Rectangle caret= getCaretRectangle(offset);
            dwt.widgets.Monitor.Monitor monitor= getClosestMonitor(display, caret);
            Rectangle bounds= monitor.getClientArea();
            Geometry.moveInside(caret, bounds);

            int spaceAbove= caret.y - bounds.y;
            int caretLowerY= caret.y + caret.height;
            int spaceBelow= bounds.y + bounds.height - caretLowerY;
            Rectangle rect;
            if (spaceAbove >= preferred.y)
                rect= new Rectangle(caret.x, caret.y - preferred.y, preferred.x, preferred.y);
            else if (spaceBelow >= preferred.y)
                rect= new Rectangle(caret.x, caretLowerY, preferred.x, preferred.y);
            // we can't fit in the preferred size - squeeze into larger area
            else if (spaceBelow <= spaceAbove)
                rect= new Rectangle(caret.x, bounds.y, preferred.x, spaceAbove);
            else
                rect= new Rectangle(caret.x, caretLowerY, preferred.x, spaceBelow);

            return constrainHorizontally(rect, bounds);
        }
        package Rectangle computeBoundsAboveBelow_package(Shell shell, Point preferred, int offset) {
            return computeBoundsAboveBelow(shell, preferred, offset);
        }

        /**
         * Returns the display bounds for <code>shell</code> such that it appears right below
         * <code>offset</code>, or above it if below is not suitable. The returned bounds lie
         * within the monitor at the caret location and never overlap with the caret line.
         *
         * @param shell the shell to compute the placement for
         * @param preferred the preferred size for <code>shell</code>
         * @param offset the caret offset in the subject control
         * @param popup a popup to inform if the location was switched to above, <code>null</code> to do nothing
         * @return the point right below <code>offset</code> in display coordinates
         * @since 3.3
         */
        protected Rectangle computeBoundsBelowAbove(Shell shell, Point preferred, int offset, CompletionProposalPopup popup) {
            Control subjectControl= fContentAssistSubjectControlAdapter.getControl();
            Display display= subjectControl.getDisplay();
            Rectangle caret= getCaretRectangle(offset);
            dwt.widgets.Monitor.Monitor monitor= getClosestMonitor(display, caret);
            Rectangle bounds= monitor.getClientArea();
            Geometry.moveInside(caret, bounds);

            int threshold= popup is null ? Integer.MAX_VALUE : popup.getMinimalHeight();
            int spaceAbove= caret.y - bounds.y;
            int spaceBelow= bounds.y + bounds.height - (caret.y + caret.height);
            Rectangle rect;
            bool switched= false;
            if (spaceBelow >= preferred.y)
                rect= new Rectangle(caret.x, caret.y + caret.height, preferred.x, preferred.y);
            // squeeze in below if we have at least threshold space
            else if (spaceBelow >= threshold)
                rect= new Rectangle(caret.x, caret.y + caret.height, preferred.x, spaceBelow);
            else if (spaceAbove >= preferred.y) {
                rect= new Rectangle(caret.x, caret.y - preferred.y, preferred.x, preferred.y);
                switched= true;
            } else if (spaceBelow >= spaceAbove) {
                // we can't fit in the preferred size - squeeze into larger area
                rect= new Rectangle(caret.x, caret.y + caret.height, preferred.x, spaceBelow);
            } else {
                rect= new Rectangle(caret.x, bounds.y, preferred.x, spaceAbove);
                switched= true;
            }

            if (popup !is null)
                popup.switchedPositionToAbove(switched);

            return constrainHorizontally(rect, bounds);
        }
        package Rectangle computeBoundsBelowAbove_package(Shell shell, Point preferred, int offset, CompletionProposalPopup popup) {
            return computeBoundsBelowAbove(shell, preferred, offset, popup );
        }

        private Rectangle getCaretRectangle(int offset) {
            Point location= fContentAssistSubjectControlAdapter.getLocationAtOffset(offset);
            Control subjectControl= fContentAssistSubjectControlAdapter.getControl();
            Point controlSize= subjectControl.getSize();
            constrainLocation(location, new Point(0, 0), new Rectangle(0, 0, controlSize.x, controlSize.y));
            location= subjectControl.toDisplay(location);
            Rectangle subjectRectangle= new Rectangle(location.x, location.y, 1, fContentAssistSubjectControlAdapter.getLineHeight());
            return subjectRectangle;
        }

        protected Point getStackedLocation(Shell shell, Shell parent) {
            Point p= parent.getLocation();
            Point size= parent.getSize();
            p.x += size.x / 4;
            p.y += size.y;

            p= parent.toDisplay(p);

            Point shellSize= shell.getSize();
            dwt.widgets.Monitor.Monitor monitor= getClosestMonitor(parent.getDisplay(), new Rectangle(p.x, p.y, 0, 0));
            Rectangle displayBounds= monitor.getClientArea();
            constrainLocation(p, shellSize, displayBounds);

            return p;
        }

        protected void adjustListeners(int type) {
            switch (type) {
                case LAYOUT_PROPOSAL_SELECTOR:
                    if (fContextType is LAYOUT_CONTEXT_SELECTOR &&
                            Helper.okToUse(fShells[LAYOUT_CONTEXT_SELECTOR]))
                        // Disable event notification to the tip selector.
                        removeContentAssistListener(cast(IContentAssistListener) fPopups[LAYOUT_CONTEXT_SELECTOR], CONTEXT_SELECTOR);
                    break;
                case LAYOUT_CONTEXT_SELECTOR:
                    if (Helper.okToUse(fShells[LAYOUT_PROPOSAL_SELECTOR]))
                        // Disable event notification to the proposal selector.
                        removeContentAssistListener(cast(IContentAssistListener) fPopups[LAYOUT_PROPOSAL_SELECTOR], PROPOSAL_SELECTOR);
                    break;
                case LAYOUT_CONTEXT_INFO_POPUP:
                    break;
                default:
            }
        }

        /**
         * Copied from dwtx.jface.window.Window.
         * Returns the monitor whose client area contains the given point. If no
         * monitor contains the point, returns the monitor that is closest to the
         * point. If this is ever made public, it should be moved into a separate
         * utility class.
         *
         * @param toSearch
         *            point to find (display coordinates)
         * @param rectangle
         *            rectangle to find (display coordinates)
         * @return the monitor closest to the given point
         * @since 3.3
         */
        private dwt.widgets.Monitor.Monitor getClosestMonitor(Display toSearch, Rectangle rectangle) {
            int closest = Integer.MAX_VALUE;

            Point toFind= Geometry.centerPoint(rectangle);
            dwt.widgets.Monitor.Monitor[] monitors = toSearch.getMonitors();
            dwt.widgets.Monitor.Monitor result = monitors[0];

            for (int idx = 0; idx < monitors.length; idx++) {
                dwt.widgets.Monitor.Monitor current = monitors[idx];

                Rectangle clientArea = current.getClientArea();

                if (clientArea.contains(toFind)) {
                    return current;
                }

                int distance = Geometry.distanceSquared(Geometry.centerPoint(clientArea), toFind);
                if (distance < closest) {
                    closest = distance;
                    result = current;
                }
            }

            return result;
        }
    }

    /**
     * Internal key listener and event consumer.
     */
    class InternalListener : VerifyKeyListener, IEventConsumer {

        /**
         * Verifies key events by notifying the registered listeners. Each listener is allowed to
         * indicate that the event has been handled and should not be further processed.
         *
         * @param e the verify event
         * @see VerifyKeyListener#verifyKey(dwt.events.VerifyEvent)
         */
        public void verifyKey(VerifyEvent e) {
            IContentAssistListener[] listeners= arraycast!(IContentAssistListener)( fListeners.dup );
            for (int i= 0; i < listeners.length; i++) {
                if (listeners[i] !is null) {
                    if (!listeners[i].verifyKey(e) || !e.doit)
                        break;
                }
            }
            if (fAutoAssistListener !is null)
                fAutoAssistListener.keyPressed(e);
        }

        /*
         * @see IEventConsumer#processEvent
         */
        public void processEvent(VerifyEvent event) {

            installKeyListener();

            IContentAssistListener[] listeners= arraycast!(IContentAssistListener)( fListeners.dup );
            for (int i= 0; i < listeners.length; i++) {
                if (listeners[i] !is null) {
                    listeners[i].processEvent(event);
                    if (!event.doit)
                        return;
                }
            }
        }
    }

    /**
     * Dialog store constants.
     *
     * @since 3.0
     */
    public static const String STORE_SIZE_X= "size.x"; //$NON-NLS-1$
    public static const String STORE_SIZE_Y= "size.y"; //$NON-NLS-1$

    // Content-Assist Listener types
    const static int CONTEXT_SELECTOR= 0;
    const static int PROPOSAL_SELECTOR= 1;
    const static int CONTEXT_INFO_POPUP= 2;

    /**
     * The popup priority: &gt; linked position proposals and hover pop-ups. Default value:
     * <code>20</code>;
     *
     * @since 3.0
     */
    public static const int WIDGET_PRIORITY= 20;

    private static const int DEFAULT_AUTO_ACTIVATION_DELAY= 500;

    private IInformationControlCreator fInformationControlCreator;
    private int fAutoActivationDelay= DEFAULT_AUTO_ACTIVATION_DELAY;
    private bool fIsAutoActivated= false;
    private bool fIsAutoInserting= false;
    private int fProposalPopupOrientation= PROPOSAL_OVERLAY;
    private int fContextInfoPopupOrientation= CONTEXT_INFO_ABOVE;
    private Map fProcessors;

    /**
     * The partitioning.
     *
     * @since 3.0
     */
    private String fPartitioning;

    private Color fContextInfoPopupBackground;
    private Color fContextInfoPopupForeground;
    private Color fContextSelectorBackground;
    private Color fContextSelectorForeground;
    private Color fProposalSelectorBackground;
    private Color fProposalSelectorForeground;

    private ITextViewer fViewer;
    private String fLastErrorMessage;

    private Closer fCloser;
    LayoutManager fLayoutManager;
    private AutoAssistListener fAutoAssistListener;
    private InternalListener fInternalListener;
    private CompletionProposalPopup fProposalPopup;
    private ContextInformationPopup fContextInfoPopup;

    /**
     * Flag which tells whether a verify key listener is hooked.
     *
     * @since 3.0
     */
    private bool fVerifyKeyListenerHooked= false;
    private IContentAssistListener[] fListeners;
    /**
     * The content assist subject control.
     *
     * @since 3.0
     */
    private IContentAssistSubjectControl fContentAssistSubjectControl;
    /**
     * The content assist subject control's shell.
     *
     * @since 3.2
     */
    private Shell fContentAssistSubjectControlShell;
    /**
     * The content assist subject control's shell traverse listener.
     *
     * @since 3.2
     */
    private TraverseListener fCASCSTraverseListener;
    /**
     * The content assist subject control adapter.
     *
     * @since 3.0
     */
    private ContentAssistSubjectControlAdapter fContentAssistSubjectControlAdapter;
    /**
     * The dialog settings for the control's bounds.
     *
     * @since 3.0
     */
    private IDialogSettings fDialogSettings;
    /**
     * Prefix completion setting.
     *
     * @since 3.0
     */
    private bool fIsPrefixCompletionEnabled= false;
    /**
     * The list of completion listeners.
     *
     * @since 3.2
     */
    private ListenerList fCompletionListeners;
    /**
     * The message to display at the bottom of the proposal popup.
     *
     * @since 3.2
     */
    private String fMessage= ""; //$NON-NLS-1$
    /**
     * The cycling mode property.
     *
     * @since 3.2
     */
    private bool fIsRepetitionMode= false;
    /**
     * The show empty property.
     *
     * @since 3.2
     */
    private bool fShowEmptyList= false;
    /**
     * The message line property.
     *
     * @since 3.2
     */
    private bool fIsStatusLineVisible;
    /**
     * The last system time when auto activation performed.
     *
     * @since 3.2
     */
    private long fLastAutoActivation= Long.MIN_VALUE;
    /**
     * The iteration key sequence to listen for, or <code>null</code>.
     *
     * @since 3.2
     */
    private KeySequence fRepeatedInvocationKeySequence;

    /**
     * Maps handler to command identifiers.
     *
     * @since 3.4
     */
    private Map fHandlers;

    /**
     * Tells whether colored labels support is enabled.
     *
     * @since 3.4
     */
    private bool fIsColoredLabelsSupportEnabled= false;


    /**
     * Creates a new content assistant. The content assistant is not automatically activated,
     * overlays the completion proposals with context information list if necessary, and shows the
     * context information above the location at which it was activated. If auto activation will be
     * enabled, without further configuration steps, this content assistant is activated after a 500
     * milliseconds delay. It uses the default partitioning.
     */
    public this() {
        fListeners= new IContentAssistListener[4];
        fCompletionListeners= new ListenerList(ListenerList.IDENTITY);
        fPartitioning= IDocumentExtension3.DEFAULT_PARTITIONING;
    }

    /**
     * Sets the document partitioning this content assistant is using.
     *
     * @param partitioning the document partitioning for this content assistant
     * @since 3.0
     */
    public void setDocumentPartitioning(String partitioning) {
        Assert.isNotNull(partitioning);
        fPartitioning= partitioning;
    }

    /*
     * @see dwtx.jface.text.contentassist.IContentAssistantExtension#getDocumentPartitioning()
     * @since 3.0
     */
    public String getDocumentPartitioning() {
        return fPartitioning;
    }

    /**
     * Registers a given content assist processor for a particular content type. If there is already
     * a processor registered for this type, the new processor is registered instead of the old one.
     *
     * @param processor the content assist processor to register, or <code>null</code> to remove
     *        an existing one
     * @param contentType the content type under which to register
     */
    public void setContentAssistProcessor(IContentAssistProcessor processor, String contentType) {

        Assert.isNotNull(contentType);

        if (fProcessors is null)
            fProcessors= new HashMap();

        if (processor is null)
            fProcessors.remove(contentType);
        else
            fProcessors.put(contentType, cast(Object)processor);
    }

    /*
     * @see IContentAssistant#getContentAssistProcessor
     */
    public IContentAssistProcessor getContentAssistProcessor(String contentType) {
        if (fProcessors is null)
            return null;

        return cast(IContentAssistProcessor) fProcessors.get(contentType);
    }

    /**
     * Computes the sorted set of all auto activation trigger characters.
     *
     * @return the sorted set of all auto activation trigger characters
     * @since 3.1
     */
    private String computeAllAutoActivationTriggers() {
        if (fProcessors is null)
            return ""; //$NON-NLS-1$

        StringBuffer buf= new StringBuffer(5);
        Iterator iter= fProcessors.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry entry= cast(Map.Entry) iter.next();
            IContentAssistProcessor processor= cast(IContentAssistProcessor) entry.getValue();
            char[] triggers= processor.getCompletionProposalAutoActivationCharacters();
            if (triggers !is null)
                buf.append(triggers);
            triggers= processor.getContextInformationAutoActivationCharacters();
            if (triggers !is null)
                buf.append(triggers);
        }
        return buf.toString();
    }

    /**
     * Enables the content assistant's auto activation mode.
     *
     * @param enabled indicates whether auto activation is enabled or not
     */
    public void enableAutoActivation(bool enabled) {
        fIsAutoActivated= enabled;
        manageAutoActivation(fIsAutoActivated);
    }

    /**
     * Enables the content assistant's auto insertion mode. If enabled, the content assistant
     * inserts a proposal automatically if it is the only proposal. In the case of ambiguities, the
     * user must make the choice.
     *
     * @param enabled indicates whether auto insertion is enabled or not
     * @since 2.0
     */
    public void enableAutoInsert(bool enabled) {
        fIsAutoInserting= enabled;
    }

    /**
     * Returns whether this content assistant is in the auto insertion mode or not.
     *
     * @return <code>true</code> if in auto insertion mode
     * @since 2.0
     */
    bool isAutoInserting() {
        return fIsAutoInserting;
    }

    /**
     * Installs and uninstall the listeners needed for auto activation.
     *
     * @param start <code>true</code> if listeners must be installed, <code>false</code> if they
     *        must be removed
     * @since 2.0
     */
    private void manageAutoActivation(bool start) {
        if (start) {

            if ((fContentAssistSubjectControlAdapter !is null) && fAutoAssistListener is null) {
                fAutoAssistListener= createAutoAssistListener();
                // For details see https://bugs.eclipse.org/bugs/show_bug.cgi?id=49212
                if (fContentAssistSubjectControlAdapter.supportsVerifyKeyListener())
                    fContentAssistSubjectControlAdapter.appendVerifyKeyListener(fAutoAssistListener);
                else
                    fContentAssistSubjectControlAdapter.addKeyListener(fAutoAssistListener);
            }

        } else if (fAutoAssistListener !is null) {
            // For details see: https://bugs.eclipse.org/bugs/show_bug.cgi?id=49212
            if (fContentAssistSubjectControlAdapter.supportsVerifyKeyListener())
                fContentAssistSubjectControlAdapter.removeVerifyKeyListener(fAutoAssistListener);
            else
                fContentAssistSubjectControlAdapter.removeKeyListener(fAutoAssistListener);
            fAutoAssistListener= null;
        }
    }

    /**
     * This method allows subclasses to provide their own {@link AutoAssistListener}.
     *
     * @return a new auto assist listener
     * @since 3.4
     */
    protected AutoAssistListener createAutoAssistListener() {
        return new AutoAssistListener();
    }

    /**
     * Sets the delay after which the content assistant is automatically invoked if the cursor is
     * behind an auto activation character.
     *
     * @param delay the auto activation delay
     */
    public void setAutoActivationDelay(int delay) {
        fAutoActivationDelay= delay;
    }

    /**
     * Gets the delay after which the content assistant is automatically invoked if the cursor is
     * behind an auto activation character.
     *
     * @return the auto activation delay
     * @since 3.4
     */
    public int getAutoActivationDelay() {
        return fAutoActivationDelay;
    }

    /**
     * Sets the proposal pop-ups' orientation. The following values may be used:
     * <ul>
     *   <li>PROPOSAL_OVERLAY<p>
     *     proposal popup windows should overlay each other
     *   </li>
     *   <li>PROPOSAL_REMOVE<p>
     *     any currently shown proposal popup should be closed
     *   </li>
     *   <li>PROPOSAL_STACKED<p>
     *     proposal popup windows should be vertical stacked, with no overlap,
     *     beneath the line containing the current cursor location
     *   </li>
     * </ul>
     *
     * @param orientation the popup's orientation
     */
    public void setProposalPopupOrientation(int orientation) {
        fProposalPopupOrientation= orientation;
    }

    /**
     * Sets the context information popup's orientation.
     * The following values may be used:
     * <ul>
     *   <li>CONTEXT_ABOVE<p>
     *     context information popup should always appear above the line containing
     *     the current cursor location
     *   </li>
     *   <li>CONTEXT_BELOW<p>
     *     context information popup should always appear below the line containing
     *     the current cursor location
     *   </li>
     * </ul>
     *
     * @param orientation the popup's orientation
     */
    public void setContextInformationPopupOrientation(int orientation) {
        fContextInfoPopupOrientation= orientation;
    }

    /**
     * Sets the context information popup's background color.
     *
     * @param background the background color
     */
    public void setContextInformationPopupBackground(Color background) {
        fContextInfoPopupBackground= background;
    }

    /**
     * Returns the background of the context information popup.
     *
     * @return the background of the context information popup
     * @since 2.0
     */
    Color getContextInformationPopupBackground() {
        return fContextInfoPopupBackground;
    }

    /**
     * Sets the context information popup's foreground color.
     *
     * @param foreground the foreground color
     * @since 2.0
     */
    public void setContextInformationPopupForeground(Color foreground) {
        fContextInfoPopupForeground= foreground;
    }

    /**
     * Returns the foreground of the context information popup.
     *
     *
     * @return the foreground of the context information popup
     * @since 2.0
     */
    Color getContextInformationPopupForeground() {
        return fContextInfoPopupForeground;
    }

    /**
     * Sets the proposal selector's background color.
     * <p>
     * <strong>Note:</strong> As of 3.4, you should only call this
     * method if you want to override the {@link JFacePreferences#CONTENT_ASSIST_BACKGROUND_COLOR}.
     * </p>
     *
     * @param background the background color
     * @since 2.0
     */
    public void setProposalSelectorBackground(Color background) {
        fProposalSelectorBackground= background;
    }

    /**
     * Returns the custom background color of the proposal selector.
     *
     * @return the background of the proposal selector or <code>null</code> if not set
     * @since 2.0
     */
    Color getProposalSelectorBackground() {
        return fProposalSelectorBackground;
    }

    /**
     * Sets the proposal's foreground color.
     * <p>
     * <strong>Note:</strong> As of 3.4, you should only call this
     * method if you want to override the {@link JFacePreferences#CONTENT_ASSIST_FOREGROUND_COLOR}.
     * </p>
     *
     * @param foreground the foreground color
     * @since 2.0
     */
    public void setProposalSelectorForeground(Color foreground) {
        fProposalSelectorForeground= foreground;
    }

    /**
     * Returns the custom foreground color of the proposal selector.
     *
     * @return the foreground of the proposal selector or <code>null</code> if not set
     * @since 2.0
     */
    Color getProposalSelectorForeground() {
        return fProposalSelectorForeground;
    }

    /**
     * Sets the context selector's background color.
     *
     * @param background the background color
     * @since 2.0
     */
    public void setContextSelectorBackground(Color background) {
        fContextSelectorBackground= background;
    }

    /**
     * Returns the background of the context selector.
     *
     * @return the background of the context selector
     * @since 2.0
     */
    Color getContextSelectorBackground() {
        return fContextSelectorBackground;
    }

    /**
     * Sets the context selector's foreground color.
     *
     * @param foreground the foreground color
     * @since 2.0
     */
    public void setContextSelectorForeground(Color foreground) {
        fContextSelectorForeground= foreground;
    }

    /**
     * Returns the foreground of the context selector.
     *
     * @return the foreground of the context selector
     * @since 2.0
     */
    Color getContextSelectorForeground() {
        return fContextSelectorForeground;
    }

    /**
     * Sets the information control creator for the additional information control.
     *
     * @param creator the information control creator for the additional information control
     * @since 2.0
     */
    public void setInformationControlCreator(IInformationControlCreator creator) {
        fInformationControlCreator= creator;
    }

    /*
     * @see IControlContentAssistant#install(IContentAssistSubjectControl)
     * @since 3.0
     */
    protected void install(IContentAssistSubjectControl contentAssistSubjectControl) {
        fContentAssistSubjectControl= contentAssistSubjectControl;
        fContentAssistSubjectControlAdapter= new ContentAssistSubjectControlAdapter(fContentAssistSubjectControl);
        install();
    }

    /*
     * @see IContentAssist#install
     * @since 3.0
     */
    public void install(ITextViewer textViewer) {
        fViewer= textViewer;
        fContentAssistSubjectControlAdapter= new ContentAssistSubjectControlAdapter(fViewer);
        install();
    }

    protected void install() {

        fLayoutManager= new LayoutManager();
        fInternalListener= new InternalListener();

        AdditionalInfoController controller= null;
        if (fInformationControlCreator !is null) {
            int delay= fAutoActivationDelay;
            if (delay is 0)
                delay= DEFAULT_AUTO_ACTIVATION_DELAY;
            delay= cast(int)Math.round(delay * 1.5f);
            controller= new AdditionalInfoController(fInformationControlCreator, delay);
        }

        fContextInfoPopup= fContentAssistSubjectControlAdapter.createContextInfoPopup(this);
        fProposalPopup= fContentAssistSubjectControlAdapter.createCompletionProposalPopup(this, controller);

        registerHandler(SELECT_NEXT_PROPOSAL_COMMAND_ID, fProposalPopup.createProposalSelectionHandler(CompletionProposalPopup.ProposalSelectionHandler.SELECT_NEXT));
        registerHandler(SELECT_PREVIOUS_PROPOSAL_COMMAND_ID, fProposalPopup.createProposalSelectionHandler(CompletionProposalPopup.ProposalSelectionHandler.SELECT_PREVIOUS));

        if (Helper.okToUse(fContentAssistSubjectControlAdapter.getControl())) {
            fContentAssistSubjectControlShell= fContentAssistSubjectControlAdapter.getControl().getShell();
            fCASCSTraverseListener= new class()  TraverseListener {
                public void keyTraversed(TraverseEvent e) {
                    if (e.detail is DWT.TRAVERSE_ESCAPE && isProposalPopupActive())
                        e.doit= false;
                }
            };
            fContentAssistSubjectControlShell.addTraverseListener(fCASCSTraverseListener);
        }

        manageAutoActivation(fIsAutoActivated);
    }

    /*
     * @see IContentAssist#uninstall
     */
    public void uninstall() {
        hide();
        manageAutoActivation(false);

        if (fHandlers !is null) {
            fHandlers.clear();
            fHandlers= null;
        }

        if (fCloser !is null) {
            fCloser.uninstall();
            fCloser= null;
        }

        if (Helper.okToUse(fContentAssistSubjectControlShell))
            fContentAssistSubjectControlShell.removeTraverseListener(fCASCSTraverseListener);
        fCASCSTraverseListener= null;
        fContentAssistSubjectControlShell= null;

        fViewer= null;
        fContentAssistSubjectControl= null;
        fContentAssistSubjectControlAdapter= null;
    }

    /**
     * Adds the given shell of the specified type to the layout. Valid types are defined by
     * <code>LayoutManager</code>.
     *
     * @param popup a content assist popup
     * @param shell the shell of the content-assist popup
     * @param type the type of popup
     * @param visibleOffset the offset at which to layout the popup relative to the offset of the
     *        viewer's visible region
     * @since 2.0
     */
    void addToLayout(Object popup, Shell shell, int type, int visibleOffset) {
        fLayoutManager.add(popup, shell, type, visibleOffset);
    }

    /**
     * Layouts the registered popup of the given type relative to the given offset. The offset is
     * relative to the offset of the viewer's visible region. Valid types are defined by
     * <code>LayoutManager</code>.
     *
     * @param type the type of popup to layout
     * @param visibleOffset the offset at which to layout relative to the offset of the viewer's
     *        visible region
     * @since 2.0
     */
    void layout(int type, int visibleOffset) {
        fLayoutManager.layout(type, visibleOffset);
    }

    /**
     * Returns the layout manager.
     *
     * @return the layout manager
     * @since 3.3
     */
    LayoutManager getLayoutManager() {
        return fLayoutManager;
    }

    /**
     * Notifies the controller that a popup has lost focus.
     *
     * @param e the focus event
     */
    void popupFocusLost(FocusEvent e) {
        fCloser.focusLost(e);
    }

    /**
     * Returns the offset of the selection relative to the offset of the visible region.
     *
     * @return the offset of the selection relative to the offset of the visible region
     * @since 2.0
     */
    int getSelectionOffset() {
        return fContentAssistSubjectControlAdapter.getWidgetSelectionRange().x;
    }

    /**
     * Returns whether the widget token could be acquired. The following are valid listener types:
     * <ul>
     *   <li>AUTO_ASSIST</li>
     *   <li>CONTEXT_SELECTOR</li>
     *   <li>PROPOSAL_SELECTOR</li>
     *   <li>CONTEXT_INFO_POPUP</li>
     * </ul>
     *
     * @param type the listener type for which to acquire
     * @return <code>true</code> if the widget token could be acquired
     * @since 2.0
     */
    private bool acquireWidgetToken(int type) {
        switch (type) {
            case CONTEXT_SELECTOR:
            case PROPOSAL_SELECTOR:
                if ( cast(IWidgetTokenOwnerExtension)fContentAssistSubjectControl ) {
                    IWidgetTokenOwnerExtension extension= cast(IWidgetTokenOwnerExtension) fContentAssistSubjectControl;
                    return extension.requestWidgetToken(this, WIDGET_PRIORITY);
                } else if ( cast(IWidgetTokenOwner)fContentAssistSubjectControl ) {
                    IWidgetTokenOwner owner= cast(IWidgetTokenOwner) fContentAssistSubjectControl;
                    return owner.requestWidgetToken(this);
                } else if ( cast(IWidgetTokenOwnerExtension)fViewer ) {
                    IWidgetTokenOwnerExtension extension= cast(IWidgetTokenOwnerExtension) fViewer;
                    return extension.requestWidgetToken(this, WIDGET_PRIORITY);
                } else if ( cast(IWidgetTokenOwner)fViewer ) {
                    IWidgetTokenOwner owner= cast(IWidgetTokenOwner) fViewer;
                    return owner.requestWidgetToken(this);
                }
            default:
        }
        return true;
    }

    /**
     * Registers a content assist listener. The following are valid listener types:
     * <ul>
     *   <li>AUTO_ASSIST</li>
     *   <li>CONTEXT_SELECTOR</li>
     *   <li>PROPOSAL_SELECTOR</li>
     *   <li>CONTEXT_INFO_POPUP</li>
     * </ul>
     * Returns whether the listener could be added successfully. A listener can not be added if the
     * widget token could not be acquired.
     *
     * @param listener the listener to register
     * @param type the type of listener
     * @return <code>true</code> if the listener could be added
     */
    bool addContentAssistListener(IContentAssistListener listener, int type) {

        if (acquireWidgetToken(type)) {

            fListeners[type]= listener;

            if (fCloser is null && getNumberOfListeners() is 1) {
                fCloser= new Closer();
                fCloser.install();
                fContentAssistSubjectControlAdapter.setEventConsumer(fInternalListener);
                installKeyListener();
            } else
                promoteKeyListener();
            return true;
        }

        return false;
    }

    /**
     * Re-promotes the key listener to the first position, using prependVerifyKeyListener. This
     * ensures no other instance is filtering away the keystrokes underneath, if we've been up for a
     * while (e.g. when the context info is showing.
     *
     * @since 3.0
     */
    private void promoteKeyListener() {
        uninstallVerifyKeyListener();
        installKeyListener();
    }

    /**
     * Installs a key listener on the text viewer's widget.
     */
    private void installKeyListener() {
        if (!fVerifyKeyListenerHooked) {
            if (Helper.okToUse(fContentAssistSubjectControlAdapter.getControl())) {
                fVerifyKeyListenerHooked= fContentAssistSubjectControlAdapter.prependVerifyKeyListener(fInternalListener);
            }
        }
    }

    /**
     * Releases the previously acquired widget token if the token is no longer necessary. The
     * following are valid listener types:
     * <ul>
     *   <li>AUTO_ASSIST</li>
     *   <li>CONTEXT_SELECTOR</li>
     *   <li>PROPOSAL_SELECTOR</li>
     *   <li>CONTEXT_INFO_POPUP</li>
     * </ul>
     *
     * @param type the listener type
     * @since 2.0
     */
    private void releaseWidgetToken(int type) {
        if (fListeners[CONTEXT_SELECTOR] is null && fListeners[PROPOSAL_SELECTOR] is null) {
            IWidgetTokenOwner owner= null;
            if ( cast(IWidgetTokenOwner)fContentAssistSubjectControl )
                owner= cast(IWidgetTokenOwner) fContentAssistSubjectControl;
            else if ( cast(IWidgetTokenOwner)fViewer )
                owner= cast(IWidgetTokenOwner) fViewer;
            if (owner !is null)
                owner.releaseWidgetToken(this);
        }
    }

    /**
     * Unregisters a content assist listener.
     *
     * @param listener the listener to unregister
     * @param type the type of listener
     * @see #addContentAssistListener(IContentAssistListener, int)
     */
    void removeContentAssistListener(IContentAssistListener listener, int type) {
        fListeners[type]= null;

        if (getNumberOfListeners() is 0) {

            if (fCloser !is null) {
                fCloser.uninstall();
                fCloser= null;
            }

            uninstallVerifyKeyListener();
            fContentAssistSubjectControlAdapter.setEventConsumer(null);
        }

        releaseWidgetToken(type);
    }

    /**
     * Uninstall the key listener from the text viewer's widget.
     *
     * @since 3.0
     */
    private void uninstallVerifyKeyListener() {
        if (fVerifyKeyListenerHooked) {
            if (Helper.okToUse(fContentAssistSubjectControlAdapter.getControl()))
                fContentAssistSubjectControlAdapter.removeVerifyKeyListener(fInternalListener);
            fVerifyKeyListenerHooked= false;
        }
    }

    /**
     * Returns the number of listeners.
     *
     * @return the number of listeners
     * @since 2.0
     */
    private int getNumberOfListeners() {
        int count= 0;
        for (int i= 0; i <= CONTEXT_INFO_POPUP; i++) {
            if (fListeners[i] !is null)
                ++count;
        }
        return count;
    }

    /*
     * @see IContentAssist#showPossibleCompletions
     */
    public String showPossibleCompletions() {
        if (!prepareToShowCompletions(false))
            return null;
        if (fIsPrefixCompletionEnabled)
            return fProposalPopup.incrementalComplete();
        return fProposalPopup.showProposals(false);
    }

    /*
     * @see dwtx.jface.text.contentassist.IContentAssistantExtension#completePrefix()
     * @since 3.0
     */
    public String completePrefix() {
        if (!prepareToShowCompletions(false))
            return null;
        return fProposalPopup.incrementalComplete();
    }

    /**
     * Prepares to show content assist proposals. It returns false if auto activation has kicked in
     * recently.
     *
     * @param isAutoActivated  whether completion was triggered by auto activation
     * @return <code>true</code> if the caller should continue and show the proposals,
     *         <code>false</code> otherwise.
     * @since 3.2
     */
    private bool prepareToShowCompletions(bool isAutoActivated) {
        long current= System.currentTimeMillis();
        int gracePeriod= Math.max(fAutoActivationDelay, 200);
        if (current < fLastAutoActivation + gracePeriod)
            return false;

        promoteKeyListener();
        fireSessionBeginEvent(isAutoActivated);
        return true;
    }

    /**
     * Callback to signal this content assistant that the presentation of the possible completions
     * has been stopped.
     *
     * @since 2.1
     */
    protected void possibleCompletionsClosed() {
        fLastAutoActivation= Long.MIN_VALUE;
        storeCompletionProposalPopupSize();
    }
    package void possibleCompletionsClosed_package() {
        possibleCompletionsClosed();
    }

    /*
     * @see IContentAssist#showContextInformation
     */
    public String showContextInformation() {
        promoteKeyListener();
        if (fContextInfoPopup !is null)
            return fContextInfoPopup.showContextProposals(false);
        return null;
    }

    /**
     * Callback to signal this content assistant that the presentation of the context information
     * has been stopped.
     *
     * @since 2.1
     */
    protected void contextInformationClosed() {
    }
    package void contextInformationClosed_package() {
        contextInformationClosed();
    }

    /**
     * Requests that the specified context information to be shown.
     *
     * @param contextInformation the context information to be shown
     * @param offset the offset to which the context information refers to
     * @since 2.0
     */
    void showContextInformation(IContextInformation contextInformation, int offset) {
        if (fContextInfoPopup !is null)
            fContextInfoPopup.showContextInformation(contextInformation, offset);
    }

    /**
     * Returns the current content assist error message.
     *
     * @return an error message or <code>null</code> if no error has occurred
     */
    String getErrorMessage() {
        return fLastErrorMessage;
    }

    /**
     * Returns the content assist processor for the content type of the specified document position.
     *
     * @param viewer the text viewer
     * @param offset a offset within the document
     * @return a content-assist processor or <code>null</code> if none exists
     * @since 3.0
     */
    private IContentAssistProcessor getProcessor(ITextViewer viewer, int offset) {
        try {

            IDocument document= viewer.getDocument();
            String type= TextUtilities.getContentType(document, getDocumentPartitioning(), offset, true);

            return getContentAssistProcessor(type);

        } catch (BadLocationException x) {
        }

        return null;
    }

    /**
     * Returns the content assist processor for the content type of the specified document position.
     *
     * @param contentAssistSubjectControl the content assist subject control
     * @param offset a offset within the document
     * @return a content-assist processor or <code>null</code> if none exists
     * @since 3.0
     */
    private IContentAssistProcessor getProcessor(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
        try {

            IDocument document= contentAssistSubjectControl.getDocument();
            String type;
            if (document !is null)
                type= TextUtilities.getContentType(document, getDocumentPartitioning(), offset, true);
            else
                type= IDocument.DEFAULT_CONTENT_TYPE;

            return getContentAssistProcessor(type);

        } catch (BadLocationException x) {
        }

        return null;
    }

    /**
     * Returns an array of completion proposals computed based on the specified document position.
     * The position is used to determine the appropriate content assist processor to invoke.
     *
     * @param contentAssistSubjectControl the content assist subject control
     * @param offset a document offset
     * @return an array of completion proposals
     * @see IContentAssistProcessor#computeCompletionProposals(ITextViewer, int)
     * @since 3.0
     */
    ICompletionProposal[] computeCompletionProposals(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
        fLastErrorMessage= null;

        ICompletionProposal[] result= null;

        IContentAssistProcessor p= getProcessor(contentAssistSubjectControl, offset);
        if ( cast(ISubjectControlContentAssistProcessor)p ) {
            result= (cast(ISubjectControlContentAssistProcessor) p).computeCompletionProposals(contentAssistSubjectControl, offset);
            fLastErrorMessage= p.getErrorMessage();
        }

        return result;
    }

    /**
     * Returns an array of completion proposals computed based on the specified document position.
     * The position is used to determine the appropriate content assist processor to invoke.
     *
     * @param viewer the viewer for which to compute the proposals
     * @param offset a document offset
     * @return an array of completion proposals or <code>null</code> if no proposals are possible
     * @see IContentAssistProcessor#computeCompletionProposals(ITextViewer, int)
     */
    ICompletionProposal[] computeCompletionProposals(ITextViewer viewer, int offset) {
        fLastErrorMessage= null;

        ICompletionProposal[] result= null;

        IContentAssistProcessor p= getProcessor(viewer, offset);
        if (p !is null) {
            result= p.computeCompletionProposals(viewer, offset);
            fLastErrorMessage= p.getErrorMessage();
        }

        return result;
    }

    /**
     * Returns an array of context information objects computed based on the specified document
     * position. The position is used to determine the appropriate content assist processor to
     * invoke.
     *
     * @param viewer the viewer for which to compute the context information
     * @param offset a document offset
     * @return an array of context information objects
     * @see IContentAssistProcessor#computeContextInformation(ITextViewer, int)
     */
    IContextInformation[] computeContextInformation(ITextViewer viewer, int offset) {
        fLastErrorMessage= null;

        IContextInformation[] result= null;

        IContentAssistProcessor p= getProcessor(viewer, offset);
        if (p !is null) {
            result= p.computeContextInformation(viewer, offset);
            fLastErrorMessage= p.getErrorMessage();
        }

        return result;
    }

    /**
     * Returns an array of context information objects computed based on the specified document
     * position. The position is used to determine the appropriate content assist processor to
     * invoke.
     *
     * @param contentAssistSubjectControl the content assist subject control
     * @param offset a document offset
     * @return an array of context information objects
     * @see IContentAssistProcessor#computeContextInformation(ITextViewer, int)
     * @since 3.0
     */
    IContextInformation[] computeContextInformation(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
        fLastErrorMessage= null;

        IContextInformation[] result= null;

        IContentAssistProcessor p= getProcessor(contentAssistSubjectControl, offset);
        if ( cast(ISubjectControlContentAssistProcessor)p ) {
            result= (cast(ISubjectControlContentAssistProcessor) p).computeContextInformation(contentAssistSubjectControl, offset);
            fLastErrorMessage= p.getErrorMessage();
        }

        return result;
    }

    /**
     * Returns the context information validator that should be used to determine when the currently
     * displayed context information should be dismissed. The position is used to determine the
     * appropriate content assist processor to invoke.
     *
     * @param viewer the text viewer
     * @param offset a document offset
     * @return an validator
     * @see IContentAssistProcessor#getContextInformationValidator()
     * @since 3.0
     */
    IContextInformationValidator getContextInformationValidator(ITextViewer viewer, int offset) {
        IContentAssistProcessor p= getProcessor(viewer, offset);
        return p !is null ? p.getContextInformationValidator() : null;
    }

    /**
     * Returns the context information validator that should be used to determine when the currently
     * displayed context information should be dismissed. The position is used to determine the
     * appropriate content assist processor to invoke.
     *
     * @param contentAssistSubjectControl the content assist subject control
     * @param offset a document offset
     * @return an validator
     * @see IContentAssistProcessor#getContextInformationValidator()
     * @since 3.0
     */
    IContextInformationValidator getContextInformationValidator(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
        IContentAssistProcessor p= getProcessor(contentAssistSubjectControl, offset);
        return p !is null ? p.getContextInformationValidator() : null;
    }

    /**
     * Returns the context information presenter that should be used to display context information.
     * The position is used to determine the appropriate content assist processor to invoke.
     *
     * @param viewer the text viewer
     * @param offset a document offset
     * @return a presenter
     * @since 2.0
     */
    IContextInformationPresenter getContextInformationPresenter(ITextViewer viewer, int offset) {
        IContextInformationValidator validator= getContextInformationValidator(viewer, offset);
        if ( cast(IContextInformationPresenter)validator )
            return cast(IContextInformationPresenter) validator;
        return null;
    }

    /**
     * Returns the context information presenter that should be used to display context information.
     * The position is used to determine the appropriate content assist processor to invoke.
     *
     * @param contentAssistSubjectControl the content assist subject control
     * @param offset a document offset
     * @return a presenter
     * @since 3.0
     */
    IContextInformationPresenter getContextInformationPresenter(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
        IContextInformationValidator validator= getContextInformationValidator(contentAssistSubjectControl, offset);
        if ( cast(IContextInformationPresenter)validator )
            return cast(IContextInformationPresenter) validator;
        return null;
    }

    /**
     * Returns the characters which when typed by the user should automatically initiate proposing
     * completions. The position is used to determine the appropriate content assist processor to
     * invoke.
     *
     * @param contentAssistSubjectControl the content assist subject control
     * @param offset a document offset
     * @return the auto activation characters
     * @see IContentAssistProcessor#getCompletionProposalAutoActivationCharacters()
     * @since 3.0
     */
    char[] getCompletionProposalAutoActivationCharacters(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
        IContentAssistProcessor p= getProcessor(contentAssistSubjectControl, offset);
        return p !is null ? p.getCompletionProposalAutoActivationCharacters() : null;
    }

    /**
     * Returns the characters which when typed by the user should automatically initiate proposing
     * completions. The position is used to determine the appropriate content assist processor to
     * invoke.
     *
     * @param viewer the text viewer
     * @param offset a document offset
     * @return the auto activation characters
     * @see IContentAssistProcessor#getCompletionProposalAutoActivationCharacters()
     */
    char[] getCompletionProposalAutoActivationCharacters(ITextViewer viewer, int offset) {
        IContentAssistProcessor p= getProcessor(viewer, offset);
        return p !is null ? p.getCompletionProposalAutoActivationCharacters() : null;
    }

    /**
     * Returns the characters which when typed by the user should automatically initiate the
     * presentation of context information. The position is used to determine the appropriate
     * content assist processor to invoke.
     *
     * @param viewer the text viewer
     * @param offset a document offset
     * @return the auto activation characters
     * @see IContentAssistProcessor#getContextInformationAutoActivationCharacters()
     * @since 3.0
     */
    char[] getContextInformationAutoActivationCharacters(ITextViewer viewer, int offset) {
        IContentAssistProcessor p= getProcessor(viewer, offset);
        return p !is null ? p.getContextInformationAutoActivationCharacters() : null;
    }

    /**
     * Returns the characters which when typed by the user should automatically initiate the
     * presentation of context information. The position is used to determine the appropriate
     * content assist processor to invoke.
     *
     * @param contentAssistSubjectControl the content assist subject control
     * @param offset a document offset
     * @return the auto activation characters
     * @see IContentAssistProcessor#getContextInformationAutoActivationCharacters()
     * @since 3.0
     */
    char[] getContextInformationAutoActivationCharacters(IContentAssistSubjectControl contentAssistSubjectControl, int offset) {
        IContentAssistProcessor p= getProcessor(contentAssistSubjectControl, offset);
        return p !is null ? p.getContextInformationAutoActivationCharacters() : null;
    }

    /*
     * @see dwtx.jface.text.IWidgetTokenKeeper#requestWidgetToken(IWidgetTokenOwner)
     * @since 2.0
     */
    public bool requestWidgetToken(IWidgetTokenOwner owner) {
        return false;
    }

    /*
     * @see dwtx.jface.text.IWidgetTokenKeeperExtension#requestWidgetToken(dwtx.jface.text.IWidgetTokenOwner,
     *      int)
     * @since 3.0
     */
    public bool requestWidgetToken(IWidgetTokenOwner owner, int priority) {
        if (priority > WIDGET_PRIORITY) {
            hide();
            return true;
        }
        return false;
    }

    /*
     * @see dwtx.jface.text.IWidgetTokenKeeperExtension#setFocus(dwtx.jface.text.IWidgetTokenOwner)
     * @since 3.0
     */
    public bool setFocus(IWidgetTokenOwner owner) {
        if (fProposalPopup !is null) {
            fProposalPopup.setFocus();
            return fProposalPopup.hasFocus();
        }
        return false;
    }

    /**
     * Hides any open pop-ups.
     *
     * @since 3.0
     */
    protected void hide() {
        if (fProposalPopup !is null)
            fProposalPopup.hide();

        if (fContextInfoPopup !is null)
            fContextInfoPopup.hide();
    }
    package void hide_package() {
        hide();
    }

    // ------ control's size handling dialog settings ------

    /**
     * Tells this information control manager to open the information control with the values
     * contained in the given dialog settings and to store the control's last valid size in the
     * given dialog settings.
     * <p>
     * Note: This API is only valid if the information control implements
     * {@link dwtx.jface.text.IInformationControlExtension3}. Not following this restriction
     * will later result in an {@link UnsupportedOperationException}.
     * </p>
     * <p>
     * The constants used to store the values are:
     * <ul>
     * <li>{@link ContentAssistant#STORE_SIZE_X}</li>
     * <li>{@link ContentAssistant#STORE_SIZE_Y}</li>
     * </ul>
     * </p>
     *
     * @param dialogSettings
     * @since 3.0
     */
    public void setRestoreCompletionProposalSize(IDialogSettings dialogSettings) {
        Assert.isTrue(dialogSettings !is null);
        fDialogSettings= dialogSettings;
    }

    /**
     * Stores the content assist pop-up's size.
     */
    protected void storeCompletionProposalPopupSize() {
        if (fDialogSettings is null || fProposalPopup is null)
            return;

        Point size= fProposalPopup.getSize();
        if (size is null)
            return;

        fDialogSettings.put(STORE_SIZE_X, size.x);
        fDialogSettings.put(STORE_SIZE_Y, size.y);
    }

    /**
     * Restores the content assist pop-up's size.
     *
     * @return the stored size
     * @since 3.0
     */
    protected Point restoreCompletionProposalPopupSize() {
        if (fDialogSettings is null)
            return null;

        Point size= new Point(-1, -1);

        try {
            size.x= fDialogSettings.getInt(STORE_SIZE_X);
            size.y= fDialogSettings.getInt(STORE_SIZE_Y);
        } catch (NumberFormatException ex) {
            size.x= -1;
            size.y= -1;
        }

        // sanity check
        if (size.x is -1 && size.y is -1)
            return null;

        Rectangle maxBounds= null;
        if (fContentAssistSubjectControl !is null && Helper.okToUse(fContentAssistSubjectControl.getControl()))
            maxBounds= fContentAssistSubjectControl.getControl().getDisplay().getBounds();
        else {
            // fallback
            Display display= Display.getCurrent();
            if (display is null)
                display= Display.getDefault();
            if (display !is null && !display.isDisposed())
                maxBounds= display.getBounds();
        }

        if (size.x > -1 && size.y > -1) {
            if (maxBounds !is null) {
                size.x= Math.min(size.x, maxBounds.width);
                size.y= Math.min(size.y, maxBounds.height);
            }

            // Enforce an absolute minimal size
            size.x= Math.max(size.x, 30);
            size.y= Math.max(size.y, 30);
        }

        return size;
    }
    package Point restoreCompletionProposalPopupSize_package() {
        return restoreCompletionProposalPopupSize();
    }

    /**
     * Sets the prefix completion property. If enabled, content assist delegates completion to
     * prefix completion.
     *
     * @param enabled <code>true</code> to enable prefix completion, <code>false</code> to
     *        disable
     */
    public void enablePrefixCompletion(bool enabled) {
        fIsPrefixCompletionEnabled= enabled;
    }

    /**
     * Returns the prefix completion state.
     *
     * @return <code>true</code> if prefix completion is enabled, <code>false</code> otherwise
     * @since 3.2
     */
    bool isPrefixCompletionEnabled() {
        return fIsPrefixCompletionEnabled;
    }

    /**
     * Returns whether the content assistant proposal popup has the focus.
     *
     * @return <code>true</code> if the proposal popup has the focus
     * @since 3.0
     */
    public bool hasProposalPopupFocus() {
        return fProposalPopup.hasFocus();
    }

    /*
     * @see dwtx.jface.text.contentassist.IContentAssistantExtension2#addCompletionListener(dwtx.jface.text.contentassist.ICompletionListener)
     * @since 3.2
     */
    public void addCompletionListener(ICompletionListener listener) {
        Assert.isLegal(listener !is null);
        fCompletionListeners.add(cast(Object)listener);
    }

    /*
     * @see dwtx.jface.text.contentassist.IContentAssistantExtension2#removeCompletionListener(dwtx.jface.text.contentassist.ICompletionListener)
     * @since 3.2
     */
    public void removeCompletionListener(ICompletionListener listener) {
        fCompletionListeners.remove(cast(Object)listener);
    }

    /**
     * Fires a session begin event to all registered {@link ICompletionListener}s.
     *
     * @param isAutoActivated  <code>true</code> if this session was triggered by auto activation
     * @since 3.2
     */
    void fireSessionBeginEvent(bool isAutoActivated) {
        if (fContentAssistSubjectControlAdapter !is null && !isProposalPopupActive()) {
            IContentAssistProcessor processor= getProcessor(fContentAssistSubjectControlAdapter, fContentAssistSubjectControlAdapter.getSelectedRange().x);
            ContentAssistEvent event= new ContentAssistEvent(this, processor, isAutoActivated);
            Object[] listeners= fCompletionListeners.getListeners();
            for (int i= 0; i < listeners.length; i++) {
                ICompletionListener listener= cast(ICompletionListener)listeners[i];
                listener.assistSessionStarted(event);
            }
        }
    }

    /**
     * Fires a session restart event to all registered {@link ICompletionListener}s.
     *
     * @since 3.4
     */
    void fireSessionRestartEvent() {
        if (fContentAssistSubjectControlAdapter !is null) {
            IContentAssistProcessor processor= getProcessor(fContentAssistSubjectControlAdapter, fContentAssistSubjectControlAdapter.getSelectedRange().x);
            ContentAssistEvent event= new ContentAssistEvent(this, processor);
            Object[] listeners= fCompletionListeners.getListeners();
            for (int i= 0; i < listeners.length; i++) {
                ICompletionListener listener= cast(ICompletionListener)listeners[i];
                if ( cast(ICompletionListenerExtension)listener )
                    (cast(ICompletionListenerExtension)listener).assistSessionRestarted(event);
            }
        }
    }

    /**
     * Fires a session end event to all registered {@link ICompletionListener}s.
     *
     * @since 3.2
     */
    void fireSessionEndEvent() {
        if (fContentAssistSubjectControlAdapter !is null) {
            IContentAssistProcessor processor= getProcessor(fContentAssistSubjectControlAdapter, fContentAssistSubjectControlAdapter.getSelectedRange().x);
            ContentAssistEvent event= new ContentAssistEvent(this, processor);
            Object[] listeners= fCompletionListeners.getListeners();
            for (int i= 0; i < listeners.length; i++) {
                ICompletionListener listener= cast(ICompletionListener)listeners[i];
                listener.assistSessionEnded(event);
            }
        }
    }

    /*
     * @see dwtx.jface.text.contentassist.IContentAssistantExtension2#setRepeatedInvocationMode(bool)
     * @since 3.2
     */
    public void setRepeatedInvocationMode(bool cycling) {
        fIsRepetitionMode= cycling;
    }

    /**
     * Returns <code>true</code> if repeated invocation mode is enabled, <code>false</code>
     * otherwise.
     *
     * @return <code>true</code> if repeated invocation mode is enabled, <code>false</code>
     *         otherwise
     * @since 3.2
     */
    bool isRepeatedInvocationMode() {
        return fIsRepetitionMode;
    }

    /*
     * @see dwtx.jface.text.contentassist.IContentAssistantExtension2#setShowEmptyList(bool)
     * @since 3.2
     */
    public void setShowEmptyList(bool showEmpty) {
        fShowEmptyList= showEmpty;
    }

    /**
     * Returns <code>true</code> if empty lists should be displayed, <code>false</code>
     * otherwise.
     *
     * @return <code>true</code> if empty lists should be displayed, <code>false</code>
     *         otherwise
     * @since 3.2
     */
    bool isShowEmptyList() {
        return fShowEmptyList;
    }

    /*
     * @see dwtx.jface.text.contentassist.IContentAssistantExtension2#setStatusLineVisible(bool)
     * @since 3.2
     */
    public void setStatusLineVisible(bool show) {
        fIsStatusLineVisible= show;
        if (fProposalPopup !is null)
            fProposalPopup.setStatusLineVisible(show);
    }

    /**
     * Returns <code>true</code> if a message line should be displayed, <code>false</code>
     * otherwise.
     *
     * @return <code>true</code> if a message line should be displayed, <code>false</code>
     *         otherwise
     * @since 3.2
     */
    bool isStatusLineVisible() {
        return fIsStatusLineVisible;
    }

    /*
     * @see dwtx.jface.text.contentassist.IContentAssistantExtension2#setStatusMessage(java.lang.String)
     * @since 3.2
     */
    public void setStatusMessage(String message) {
        Assert.isLegal(message !is null);
        fMessage= message;
        if (fProposalPopup !is null)
            fProposalPopup.setMessage(message);
    }

    /**
     * Returns the affordance caption for the cycling affordance at the bottom of the pop-up.
     *
     * @return the affordance caption for the cycling affordance at the bottom of the pop-up
     * @since 3.2
     */
    String getStatusMessage() {
        return fMessage;
    }

    /*
     * @see dwtx.jface.text.contentassist.IContentAssistantExtension2#setEmptyMessage(java.lang.String)
     * @since 3.2
     */
    public void setEmptyMessage(String message) {
        Assert.isLegal(message !is null);
        if (fProposalPopup !is null)
            fProposalPopup.setEmptyMessage(message);
    }

    /**
     * Fires a selection event, see {@link ICompletionListener}.
     *
     * @param proposal the selected proposal, possibly <code>null</code>
     * @param smartToggle true if the smart toggle is on
     * @since 3.2
     */
    void fireSelectionEvent(ICompletionProposal proposal, bool smartToggle) {
        Object[] listeners= fCompletionListeners.getListeners();
        for (int i= 0; i < listeners.length; i++) {
            ICompletionListener listener= cast(ICompletionListener)listeners[i];
            listener.selectionChanged(proposal, smartToggle);
        }
    }

    /*
     * @see dwtx.jface.text.contentassist.IContentAssistantExtension3#setInvocationTrigger(dwtx.jface.bindings.keys.KeySequence)
     * @since 3.2
     */
    public void setRepeatedInvocationTrigger(KeySequence sequence) {
        fRepeatedInvocationKeySequence= sequence;
    }

    /**
     * Returns the repeated invocation key sequence.
     *
     * @return the repeated invocation key sequence or <code>null</code>, if none
     * @since 3.2
     */
    KeySequence getRepeatedInvocationKeySequence() {
        return fRepeatedInvocationKeySequence;
    }

    /**
     * Returns whether proposal popup is active.
     *
     * @return <code>true</code> if the proposal popup is active, <code>false</code> otherwise
     * @since 3.4
     */
    protected bool isProposalPopupActive(){
        return fProposalPopup !is null && fProposalPopup.isActive();
    }

    /**
     * Returns whether the context information popup is active.
     *
     * @return <code>true</code> if the context information popup is active, <code>false</code> otherwise
     * @since 3.4
     */
    protected bool isContextInfoPopupActive(){
        return fContextInfoPopup !is null && fContextInfoPopup.isActive();
    }

    /**
     * {@inheritDoc}
     *
     * @since 3.4
     */
    public final IHandler getHandler(String commandId) {
        if (fHandlers is null)
            throw new IllegalStateException();

        IHandler handler= cast(IHandler)fHandlers.get(commandId);
        if (handler !is null)
            return handler;

        Assert.isLegal(false);
        return null;
    }

    /**
     * Registers the given handler under the given command identifier.
     *
     * @param commandId the command identifier
     * @param handler the handler
     * @since 3.4
     */
    protected final void registerHandler(String commandId, IHandler handler) {
        if (fHandlers is null)
            fHandlers= new HashMap(2);
        fHandlers.put(commandId, cast(Object)handler);
    }

    /**
     * Tells whether the support for colored labels is enabled.
     *
     * @return <code>true</code> if the support for colored labels is enabled, <code>false</code> otherwise
     * @since 3.4
     */
    bool isColoredLabelsSupportEnabled() {
        return fIsColoredLabelsSupportEnabled;
    }

    /**
     * Enables the support for colored labels in the proposal popup.
     * <p>Completion proposals can implement {@link ICompletionProposalExtension6}
     * to provide colored proposal labels.</p>
     *
     * @param isEnabled if <code>true</code> the support for colored labels is enabled in the proposal popup
     * @since 3.4
     */
    public void enableColoredLabels(bool isEnabled) {
        fIsColoredLabelsSupportEnabled= isEnabled;
    }

}