* 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

*******************************************************************************/

* The standard implementation of the <code>IContentAssistant</code> interface. Usually, clients

* instantiate this class and configure it before using it.

*/

 

 

 

  /**

   * Content assist command identifier for 'select next proposal'.

   *

   * @since 3.4

   */

  public static final String SELECT_NEXT_PROPOSAL_COMMAND_ID= "org.eclipse.ui.edit.text.contentAssist.selectNextProposal"; //$NON-NLS-1$

  /**

   * Content assist command identifier for 'select previous proposal'.

   *

   * @since 3.4

   */

  public static final String SELECT_PREVIOUS_PROPOSAL_COMMAND_ID= "org.eclipse.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 implements 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 != 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 != 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 != null) {

          d.asyncExec(new Runnable() {

            public void run() {

              if (!fProposalPopup.hasFocus() && (fContextInfoPopup == 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 extends KeyAdapter implements KeyListener, Runnable, VerifyKeyListener {

    private Thread fThread;

    private boolean fIsReset= false;

    private Object fMutex= new Object();

    private int fShowStyle;

    private final static int SHOW_PROPOSALS= 1;

    private final static int SHOW_CONTEXT_INFO= 2;

    protected AutoAssistListener() {

    }

    protected void start(int showStyle) {

      fShowStyle= showStyle;

      fThread= new Thread(this, JFaceTextMessages.getString("ContentAssistant.assist_delay_timer_name")); //$NON-NLS-1$

      fThread.start();

    }

    public void run() {

      try {

        while (true) {

          synchronized (fMutex) {

            if (fAutoActivationDelay != 0)

              fMutex.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.notifyAll();

      }

    }

    protected void stop() {

      Thread threadToStop= fThread;

      if (threadToStop != null && threadToStop.isAlive())

        threadToStop.interrupt();

    }

    private boolean contains(char[] characters, char character) {

      if (characters != null) {

        for (int i= 0; i < characters.length; i++) {

          if (character == characters[i])

            return true;

        }

      }

      return false;

    }

    public void keyPressed(KeyEvent e) {

      // Only act on typed characters and ignore modifier-only events

      if (e.character == 0 && (e.keyCode & SWT.KEYCODE_BIT) == 0)

        return;

     

      if (e.character != 0 && (e.stateMask == SWT.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(ContentAssistant.this, pos);

      if (contains(activation, e.character) && !isProposalPopupActive())

        showStyle= SHOW_PROPOSALS;

      else {

        activation= fContentAssistSubjectControlAdapter.getContextInformationAutoActivationCharacters(ContentAssistant.this, pos);

        if (contains(activation, e.character) && !isContextInfoPopupActive())

          showStyle= SHOW_CONTEXT_INFO;

        else {

          stop();

          return;

        }

      }

      if (fThread != null && fThread.isAlive())

        reset(showStyle);

      else

        start(showStyle);

    }

    /*

     * @see org.eclipse.swt.custom.VerifyKeyListener#verifyKey(org.eclipse.swt.events.VerifyEvent)

     */

    public void verifyKey(VerifyEvent event) {

      keyPressed(event);

    }

    protected void showAssist(final int showStyle) {

      final Control control= fContentAssistSubjectControlAdapter.getControl();

      if (control == null)

        return;

     

      final Display d= control.getDisplay();

      if (d == null)

        return;

     

      try {

        d.syncExec(new Runnable() {

          public void run() {

            if (isProposalPopupActive())

              return;

           

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

              return;

           

            if (showStyle == SHOW_PROPOSALS) {

              if (!prepareToShowCompletions(true))

                return;

              fProposalPopup.showProposals(true);

              fLastAutoActivation= System.currentTimeMillis();

            } else if (showStyle == SHOW_CONTEXT_INFO && fContextInfoPopup != null) {

              promoteKeyListener();

              fContextInfoPopup.showContextProposals(true);

            }

          }

        });

      } catch (SWTError e) {

      }

    }

  }

  /**

   * The layout manager layouts the various windows associated with the content assistant based on

   * the settings of the content assistant.

   */

  class LayoutManager implements Listener {

    // Presentation types.

    /** The presentation type for the proposal selection popup. */

    public final static int LAYOUT_PROPOSAL_SELECTOR= 0;

    /** The presentation type for the context selection popup. */

    public final static int LAYOUT_CONTEXT_SELECTOR= 1;

    /** The presentation type for the context information hover . */

    public final static int LAYOUT_CONTEXT_INFO_POPUP= 2;

    int fContextType= LAYOUT_CONTEXT_SELECTOR;

    Shell[] fShells= new Shell[3];

    Object[] fPopups= new Object[3];

    protected void add(Object popup, Shell shell, int type, int offset) {

      Assert.isNotNull(popup);

      Assert.isTrue(shell != null && !shell.isDisposed());

      checkType(type);

      if (fShells[type] != shell) {

        if (fShells[type] != null)

          fShells[type].removeListener(SWT.Dispose, this);

        shell.addListener(SWT.Dispose, this);

        fShells[type]= shell;

      }

      fPopups[type]= popup;

      if (type == LAYOUT_CONTEXT_SELECTOR || type == LAYOUT_CONTEXT_INFO_POPUP)

        fContextType= type;

      layout(type, offset);

      adjustListeners(type);

    }

    protected void checkType(int type) {

      Assert.isTrue(type == LAYOUT_PROPOSAL_SELECTOR ||

        type == LAYOUT_CONTEXT_SELECTOR || type == LAYOUT_CONTEXT_INFO_POPUP);

    }

    public void handleEvent(Event event) {

      Widget source= event.widget;

      source.removeListener(SWT.Dispose, this);

      int type= getShellType(source);

      checkType(type);

      fShells[type]= null;

      switch (type) {

        case LAYOUT_PROPOSAL_SELECTOR:

          if (fContextType == LAYOUT_CONTEXT_SELECTOR &&

              Helper.okToUse(fShells[LAYOUT_CONTEXT_SELECTOR])) {

            // Restore event notification to the tip popup.

            addContentAssistListener((IContentAssistListener) fPopups[LAYOUT_CONTEXT_SELECTOR], CONTEXT_SELECTOR);

          }

          break;

        case LAYOUT_CONTEXT_SELECTOR:

          if (Helper.okToUse(fShells[LAYOUT_PROPOSAL_SELECTOR])) {

            if (fProposalPopupOrientation == PROPOSAL_STACKED)

              layout(LAYOUT_PROPOSAL_SELECTOR, getSelectionOffset());

            // Restore event notification to the proposal popup.

            addContentAssistListener((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 == CONTEXT_INFO_BELOW)

              layout(LAYOUT_PROPOSAL_SELECTOR, getSelectionOffset());

          }

          fContextType= LAYOUT_CONTEXT_SELECTOR;

          break;

      }

    }

    protected int getShellType(Widget shell) {

      for (int i= 0; i < fShells.length; i++) {

        if (fShells[i] == 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;

      }

    }

    protected void layoutProposalSelector(int offset) {

      if (fContextType == LAYOUT_CONTEXT_INFO_POPUP &&

          fContextInfoPopupOrientation == 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 != 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= (CompletionProposalPopup) fPopups[LAYOUT_PROPOSAL_SELECTOR];

        shell.setBounds(computeBoundsBelowAbove(shell, shell.getSize(), offset, popup));

      } else {

        CompletionProposalPopup popup= ((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;

          }

        }

      }

    }

    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;

          }

        }

      }

    }

    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;

        }

      }

    }

    /**

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

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

    }

    /**

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

      Monitor monitor= getClosestMonitor(display, caret);

      Rectangle bounds= monitor.getClientArea();

      Geometry.moveInside(caret, bounds);

      int threshold= popup == null ? Integer.MAX_VALUE : popup.getMinimalHeight();

      int spaceAbove= caret.y - bounds.y;

      int spaceBelow= bounds.y + bounds.height - (caret.y + caret.height);

      Rectangle rect;

      boolean 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 != null)

        popup.switchedPositionToAbove(switched);

     

      return constrainHorizontally(rect, bounds);

    }

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

      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 == LAYOUT_CONTEXT_SELECTOR &&

              Helper.okToUse(fShells[LAYOUT_CONTEXT_SELECTOR]))

            // Disable event notification to the tip selector.

            removeContentAssistListener((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((IContentAssistListener) fPopups[LAYOUT_PROPOSAL_SELECTOR], PROPOSAL_SELECTOR);

          break;

        case LAYOUT_CONTEXT_INFO_POPUP:

          break;

      }

    }

   

    /**

     * Copied from org.eclipse.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 Monitor getClosestMonitor(Display toSearch, Rectangle rectangle) {

      int closest = Integer.MAX_VALUE;

      Point toFind= Geometry.centerPoint(rectangle);

      Monitor[] monitors = toSearch.getMonitors();

      Monitor result = monitors[0];

      for (int idx = 0; idx < monitors.length; idx++) {

        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 implements 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(org.eclipse.swt.events.VerifyEvent)

     */

    public void verifyKey(VerifyEvent e) {

      IContentAssistListener[] listeners= (IContentAssistListener[]) fListeners.clone();

      for (int i= 0; i < listeners.length; i++) {

        if (listeners[i] != null) {

          if (!listeners[i].verifyKey(e) || !e.doit)

            break;

        }

      }

      if (fAutoAssistListener != null)

        fAutoAssistListener.keyPressed(e);

    }

    /*

     * @see IEventConsumer#processEvent

     */

    public void processEvent(VerifyEvent event) {

      installKeyListener();

      IContentAssistListener[] listeners= (IContentAssistListener[]) fListeners.clone();

      for (int i= 0; i < listeners.length; i++) {

        if (listeners[i] != null) {

          listeners[i].processEvent(event);

          if (!event.doit)

            return;

        }

      }

    }

  }

  /**

   * Dialog store constants.

   *

   * @since 3.0

   */

  public static final String STORE_SIZE_X= "size.x"; //$NON-NLS-1$

  public static final String STORE_SIZE_Y= "size.y"; //$NON-NLS-1$

  // Content-Assist Listener types

  final static int CONTEXT_SELECTOR= 0;

  final static int PROPOSAL_SELECTOR= 1;

  final static int CONTEXT_INFO_POPUP= 2;

  /**