Mercurial > projects > dwt2
view org.eclipse.jface.text/src/org/eclipse/jface/text/AbstractInformationControlManager.d @ 125:c43718956f21 default tip
Updated the snippets status.
author | Jacob Carlborg <doob@me.com> |
---|---|
date | Thu, 11 Aug 2011 19:55:14 +0200 |
parents | bc29606a740c |
children |
line wrap: on
line source
/******************************************************************************* * 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 * Sean Montgomery, sean_montgomery@comcast.net - https://bugs.eclipse.org/bugs/show_bug.cgi?id=45095 * Port to the D programming language: * Frank Benoit <benoit@tionex.de> *******************************************************************************/ module org.eclipse.jface.text.AbstractInformationControlManager; import org.eclipse.jface.text.IDocumentPartitioningListener; // packageimport import org.eclipse.jface.text.DefaultTextHover; // packageimport import org.eclipse.jface.text.AbstractInformationControl; // packageimport import org.eclipse.jface.text.TextUtilities; // packageimport import org.eclipse.jface.text.IInformationControlCreatorExtension; // packageimport import org.eclipse.jface.text.ITextViewerExtension2; // packageimport import org.eclipse.jface.text.IDocumentPartitioner; // packageimport import org.eclipse.jface.text.DefaultIndentLineAutoEditStrategy; // packageimport import org.eclipse.jface.text.ITextSelection; // packageimport import org.eclipse.jface.text.Document; // packageimport import org.eclipse.jface.text.FindReplaceDocumentAdapterContentProposalProvider; // packageimport import org.eclipse.jface.text.ITextListener; // packageimport import org.eclipse.jface.text.BadPartitioningException; // packageimport import org.eclipse.jface.text.ITextViewerExtension5; // packageimport import org.eclipse.jface.text.IDocumentPartitionerExtension3; // packageimport import org.eclipse.jface.text.IUndoManager; // packageimport import org.eclipse.jface.text.ITextHoverExtension2; // packageimport import org.eclipse.jface.text.IRepairableDocument; // packageimport import org.eclipse.jface.text.IRewriteTarget; // packageimport import org.eclipse.jface.text.DefaultPositionUpdater; // packageimport import org.eclipse.jface.text.RewriteSessionEditProcessor; // packageimport import org.eclipse.jface.text.TextViewerHoverManager; // packageimport import org.eclipse.jface.text.DocumentRewriteSession; // packageimport import org.eclipse.jface.text.TextViewer; // packageimport import org.eclipse.jface.text.ITextViewerExtension8; // packageimport import org.eclipse.jface.text.RegExMessages; // packageimport import org.eclipse.jface.text.IDelayedInputChangeProvider; // packageimport import org.eclipse.jface.text.ITextOperationTargetExtension; // packageimport import org.eclipse.jface.text.IWidgetTokenOwner; // packageimport import org.eclipse.jface.text.IViewportListener; // packageimport import org.eclipse.jface.text.GapTextStore; // packageimport import org.eclipse.jface.text.MarkSelection; // packageimport import org.eclipse.jface.text.IDocumentPartitioningListenerExtension; // packageimport import org.eclipse.jface.text.IDocumentAdapterExtension; // packageimport import org.eclipse.jface.text.IInformationControlExtension; // packageimport import org.eclipse.jface.text.IDocumentPartitioningListenerExtension2; // packageimport import org.eclipse.jface.text.DefaultDocumentAdapter; // packageimport import org.eclipse.jface.text.ITextViewerExtension3; // packageimport import org.eclipse.jface.text.IInformationControlCreator; // packageimport import org.eclipse.jface.text.TypedRegion; // packageimport import org.eclipse.jface.text.ISynchronizable; // packageimport import org.eclipse.jface.text.IMarkRegionTarget; // packageimport import org.eclipse.jface.text.TextViewerUndoManager; // packageimport import org.eclipse.jface.text.IRegion; // packageimport import org.eclipse.jface.text.IInformationControlExtension2; // packageimport import org.eclipse.jface.text.IDocumentExtension4; // packageimport import org.eclipse.jface.text.IDocumentExtension2; // packageimport import org.eclipse.jface.text.IDocumentPartitionerExtension2; // packageimport // import org.eclipse.jface.text.Assert; // packageimport import org.eclipse.jface.text.DefaultInformationControl; // packageimport import org.eclipse.jface.text.IWidgetTokenOwnerExtension; // packageimport import org.eclipse.jface.text.DocumentClone; // packageimport import org.eclipse.jface.text.DefaultUndoManager; // packageimport import org.eclipse.jface.text.IFindReplaceTarget; // packageimport import org.eclipse.jface.text.IAutoEditStrategy; // packageimport import org.eclipse.jface.text.ILineTrackerExtension; // packageimport import org.eclipse.jface.text.IUndoManagerExtension; // packageimport import org.eclipse.jface.text.TextSelection; // packageimport import org.eclipse.jface.text.DefaultAutoIndentStrategy; // packageimport import org.eclipse.jface.text.IAutoIndentStrategy; // packageimport import org.eclipse.jface.text.IPainter; // packageimport import org.eclipse.jface.text.IInformationControl; // packageimport import org.eclipse.jface.text.IInformationControlExtension3; // packageimport import org.eclipse.jface.text.ITextViewerExtension6; // packageimport import org.eclipse.jface.text.IInformationControlExtension4; // packageimport import org.eclipse.jface.text.DefaultLineTracker; // packageimport import org.eclipse.jface.text.IDocumentInformationMappingExtension; // packageimport import org.eclipse.jface.text.IRepairableDocumentExtension; // packageimport import org.eclipse.jface.text.ITextHover; // packageimport import org.eclipse.jface.text.FindReplaceDocumentAdapter; // packageimport import org.eclipse.jface.text.ILineTracker; // packageimport import org.eclipse.jface.text.Line; // packageimport import org.eclipse.jface.text.ITextViewerExtension; // packageimport import org.eclipse.jface.text.IDocumentAdapter; // packageimport import org.eclipse.jface.text.TextEvent; // packageimport import org.eclipse.jface.text.BadLocationException; // packageimport import org.eclipse.jface.text.AbstractDocument; // packageimport import org.eclipse.jface.text.AbstractLineTracker; // packageimport import org.eclipse.jface.text.TreeLineTracker; // packageimport import org.eclipse.jface.text.ITextPresentationListener; // packageimport import org.eclipse.jface.text.Region; // packageimport import org.eclipse.jface.text.ITextViewer; // packageimport import org.eclipse.jface.text.IDocumentInformationMapping; // packageimport import org.eclipse.jface.text.MarginPainter; // packageimport import org.eclipse.jface.text.IPaintPositionManager; // packageimport import org.eclipse.jface.text.TextPresentation; // packageimport import org.eclipse.jface.text.IFindReplaceTargetExtension; // packageimport import org.eclipse.jface.text.ISlaveDocumentManagerExtension; // packageimport import org.eclipse.jface.text.ISelectionValidator; // packageimport import org.eclipse.jface.text.IDocumentExtension; // packageimport import org.eclipse.jface.text.PropagatingFontFieldEditor; // packageimport import org.eclipse.jface.text.ConfigurableLineTracker; // packageimport import org.eclipse.jface.text.SlaveDocumentEvent; // packageimport import org.eclipse.jface.text.IDocumentListener; // packageimport import org.eclipse.jface.text.PaintManager; // packageimport import org.eclipse.jface.text.IFindReplaceTargetExtension3; // packageimport import org.eclipse.jface.text.ITextDoubleClickStrategy; // packageimport import org.eclipse.jface.text.IDocumentExtension3; // packageimport import org.eclipse.jface.text.Position; // packageimport import org.eclipse.jface.text.TextMessages; // packageimport import org.eclipse.jface.text.CopyOnWriteTextStore; // packageimport import org.eclipse.jface.text.WhitespaceCharacterPainter; // packageimport import org.eclipse.jface.text.IPositionUpdater; // packageimport import org.eclipse.jface.text.DefaultTextDoubleClickStrategy; // packageimport import org.eclipse.jface.text.ListLineTracker; // packageimport import org.eclipse.jface.text.ITextInputListener; // packageimport import org.eclipse.jface.text.BadPositionCategoryException; // packageimport import org.eclipse.jface.text.IWidgetTokenKeeperExtension; // packageimport import org.eclipse.jface.text.IInputChangedListener; // packageimport import org.eclipse.jface.text.ITextOperationTarget; // packageimport import org.eclipse.jface.text.IDocumentInformationMappingExtension2; // packageimport import org.eclipse.jface.text.ITextViewerExtension7; // packageimport import org.eclipse.jface.text.IInformationControlExtension5; // packageimport import org.eclipse.jface.text.IDocumentRewriteSessionListener; // packageimport import org.eclipse.jface.text.JFaceTextUtil; // packageimport import org.eclipse.jface.text.AbstractReusableInformationControlCreator; // packageimport import org.eclipse.jface.text.TabsToSpacesConverter; // packageimport import org.eclipse.jface.text.CursorLinePainter; // packageimport import org.eclipse.jface.text.ITextHoverExtension; // packageimport import org.eclipse.jface.text.IEventConsumer; // packageimport import org.eclipse.jface.text.IDocument; // packageimport import org.eclipse.jface.text.IWidgetTokenKeeper; // packageimport import org.eclipse.jface.text.DocumentCommand; // packageimport import org.eclipse.jface.text.TypedPosition; // packageimport import org.eclipse.jface.text.IEditingSupportRegistry; // packageimport import org.eclipse.jface.text.IDocumentPartitionerExtension; // packageimport import org.eclipse.jface.text.AbstractHoverInformationControlManager; // packageimport import org.eclipse.jface.text.IEditingSupport; // packageimport import org.eclipse.jface.text.IMarkSelection; // packageimport import org.eclipse.jface.text.ISlaveDocumentManager; // packageimport import org.eclipse.jface.text.DocumentEvent; // packageimport import org.eclipse.jface.text.DocumentPartitioningChangedEvent; // packageimport import org.eclipse.jface.text.ITextStore; // packageimport import org.eclipse.jface.text.JFaceTextMessages; // packageimport import org.eclipse.jface.text.DocumentRewriteSessionEvent; // packageimport import org.eclipse.jface.text.SequentialRewriteTextStore; // packageimport import org.eclipse.jface.text.DocumentRewriteSessionType; // packageimport import org.eclipse.jface.text.TextAttribute; // packageimport import org.eclipse.jface.text.ITextViewerExtension4; // packageimport import org.eclipse.jface.text.ITypedRegion; // packageimport import java.lang.all; import java.util.Set; import org.eclipse.swt.SWT; import org.eclipse.swt.events.DisposeEvent; import org.eclipse.swt.events.DisposeListener; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Monitor; import org.eclipse.core.runtime.Assert; import org.eclipse.core.runtime.Platform; import org.eclipse.jface.dialogs.IDialogSettings; import org.eclipse.jface.internal.text.InformationControlReplacer; import org.eclipse.jface.internal.text.InternalAccessor; import org.eclipse.jface.text.ITextViewerExtension8; import org.eclipse.jface.util.Geometry; /** * Manages the life cycle, visibility, layout, and contents of an * {@link org.eclipse.jface.text.IInformationControl}. This manager can be * installed on and removed from a control, referred to as the subject control, * i.e. the one from which the subject of the information to be shown is * retrieved. Also a manager can be enabled or disabled. An installed and * enabled manager can be forced to show information in its information control * using <code>showInformation</code>. An information control manager uses an * <code>IInformationControlCloser</code> to define the behavior when a * presented information control must be closed. The disposal of the subject and * the information control are internally handled by the information control * manager and are not the responsibility of the information control closer. * * @see org.eclipse.jface.text.IInformationControl * @since 2.0 */ abstract public class AbstractInformationControlManager { /** * An internal class that gives access to internal methods. * * @since 3.4 */ public static class MyInternalAccessor : InternalAccessor { AbstractInformationControlManager outer_; this( AbstractInformationControlManager a ){ outer_=a; } public IInformationControl getCurrentInformationControl() { return outer_.getCurrentInformationControl(); } public void setInformationControlReplacer(InformationControlReplacer replacer) { outer_.setInformationControlReplacer(replacer); } public InformationControlReplacer getInformationControlReplacer() { return outer_.getInformationControlReplacer(); } public bool canReplace(IInformationControl control) { return outer_.canReplace(control); } public bool isReplaceInProgress() { return outer_.isReplaceInProgress(); } public void replaceInformationControl(bool takeFocus) { outer_.replaceInformationControl(takeFocus); } public void cropToClosestMonitor(Rectangle bounds) { outer_.cropToClosestMonitor(bounds); } public void setHoverEnrichMode(EnrichMode mode) { throw new UnsupportedOperationException("only implemented in AbstractHoverInformationControlManager"); //$NON-NLS-1$ } public bool getAllowMouseExit() { throw new UnsupportedOperationException("only implemented in AnnotationBarHoverManager"); //$NON-NLS-1$ } } /** * Interface of an information control closer. An information control closer * monitors its information control and its subject control and closes the * information control if necessary. * <p> * Clients must implement this interface in order to equip an information * control manager accordingly. */ public interface IInformationControlCloser { /** * Sets the closer's subject control. This is the control that parents * the information control and from which the subject of the information * to be shown is retrieved. <p> * Must be called before <code>start</code>. May again be called * between <code>start</code> and <code>stop</code>. * * @param subject the subject control */ public void setSubjectControl(Control subject); /** * Sets the closer's information control, the one to close if necessary. <p> * Must be called before <code>start</code>. May again be called * between <code>start</code> and <code>stop</code>. * * @param control the information control */ public void setInformationControl(IInformationControl control); /** * Tells this closer to start monitoring the subject and the information * control. The presented information is considered valid for the given * area of the subject control's display. * * @param subjectArea the area for which the presented information is valid */ public void start(Rectangle subjectArea); /** * Tells this closer to stop monitoring the subject and the information control. */ public void stop(); } /** * Constitutes entities to enumerate anchors for the layout of the information control. */ public static final class Anchor { private const int fFlag; private this(int flag) { fFlag= flag; } /** * Returns the SWT direction flag. One of {@link SWT#BOTTOM}, {@link SWT#TOP}, * {@link SWT#LEFT}, {@link SWT#RIGHT}, {@link SWT#CENTER}, * * @return the SWT direction flag * @since 3.3 */ int getSWTFlag() { return fFlag; } public override String toString() { switch (fFlag) { case SWT.BOTTOM: return "BOTTOM"; //$NON-NLS-1$ case SWT.TOP: return "TOP"; //$NON-NLS-1$ case SWT.LEFT: return "LEFT"; //$NON-NLS-1$ case SWT.RIGHT: return "RIGHT"; //$NON-NLS-1$ case SWT.CENTER: return "CENTER"; //$NON-NLS-1$ default: return Integer.toHexString(fFlag); } } } /** Internal anchor list. */ private static Anchor[] ANCHORS_; private static Anchor[] ANCHORS() { if( ANCHORS_ is null ) ANCHORS_= [ new Anchor(SWT.TOP), new Anchor(SWT.BOTTOM), new Anchor(SWT.LEFT), new Anchor(SWT.RIGHT) ]; return ANCHORS_; } /** Anchor representing the top of the information area */ public static Anchor ANCHOR_TOP() { return ANCHORS()[0]; } /** Anchor representing the bottom of the information area */ public static Anchor ANCHOR_BOTTOM() { return ANCHORS()[1]; } /** Anchor representing the left side of the information area */ public static Anchor ANCHOR_LEFT() { return ANCHORS()[2]; } /** Anchor representing the right side of the information area */ public static Anchor ANCHOR_RIGHT() { return ANCHORS()[3]; } /** * Anchor representing the middle of the subject control * @since 2.1 */ public static Anchor ANCHOR_GLOBAL_; public static Anchor ANCHOR_GLOBAL(){ if( ANCHOR_GLOBAL_ is null ) ANCHOR_GLOBAL_ = new Anchor(SWT.CENTER); return ANCHOR_GLOBAL_; } /** * Dialog store constant for the location's x-coordinate. * @since 3.0 */ public static const String STORE_LOCATION_X= "location.x"; //$NON-NLS-1$ /** * Dialog store constant for the location's y-coordinate. * @since 3.0 */ public static const String STORE_LOCATION_Y= "location.y"; //$NON-NLS-1$ /** * Dialog store constant for the size's width. * @since 3.0 */ public static const String STORE_SIZE_WIDTH= "size.width"; //$NON-NLS-1$ /** * Dialog store constant for the size's height. * @since 3.0 */ public static const String STORE_SIZE_HEIGHT= "size.height"; //$NON-NLS-1$ /** * Tells whether this class and its subclasses are in debug mode. * <p> * Subclasses may use this. * </p> * @since 3.4 */ private static bool DEBUG_; private static bool DEBUG_init = false; protected static bool DEBUG(){ if( !DEBUG_init ){ DEBUG_init = true; DEBUG_ = "true".equalsIgnoreCase(Platform.getDebugOption("org.eclipse.jface.text/debug/AbstractInformationControlManager")); //$NON-NLS-1$//$NON-NLS-2$ } return DEBUG_; } /** The subject control of the information control */ private Control fSubjectControl; /** The display area for which the information to be presented is valid */ private Rectangle fSubjectArea; /** The information to be presented */ private Object fInformation; /** Indicates whether the information control takes focus when visible */ private bool fTakesFocusWhenVisible= false; /** * The information control. * * <p>This field should not be referenced by subclasses. It is <code>protected</code> for API * compatibility reasons. */ protected IInformationControl fInformationControl; /** * The information control creator. * * <p>This field should not be referenced by subclasses. It is <code>protected</code> for API * compatibility reasons. */ protected IInformationControlCreator fInformationControlCreator; /** * The information control closer. * * <p>This field should not be referenced by subclasses. It is <code>protected</code> for API * compatibility reasons. */ protected IInformationControlCloser fInformationControlCloser; /** * Indicates that the information control has been disposed. * * <p>This field should not be referenced by subclasses. It is <code>protected</code> for API * compatibility reasons. */ protected bool fDisposed= false; /** * The information control replacer to be used when this information control * needs to be replaced with another information control. * * @since 3.4 */ private InformationControlReplacer fInformationControlReplacer; /** Indicates the enable state of this manager */ private bool fEnabled= false; /** Cached, computed size constraints of the information control in points */ private Point fSizeConstraints; /** The vertical margin when laying out the information control */ private int fMarginY= 5; /** The horizontal margin when laying out the information control */ private int fMarginX= 5; /** The width constraint of the information control in characters */ private int fWidthConstraint= 60; /** The height constraint of the information control in characters */ private int fHeightConstraint= 6; /** Indicates whether the size constraints should be enforced as minimal control size */ private bool fEnforceAsMinimalSize= false; /** Indicates whether the size constraints should be enforced as maximal control size */ private bool fEnforceAsMaximalSize= false; /** The anchor for laying out the information control in relation to the subject control */ private Anchor fAnchor; /** * The anchor sequence used to layout the information control if the original anchor * can not be used because the information control would not fit in the display client area. * <p> * The fallback anchor for a given anchor is the one that comes directly after the given anchor or * is the first one in the sequence if the given anchor is the last one in the sequence. * <p> * </p> * Note: This sequence is ignored if the original anchor is not contained in this sequence. * </p> * * @see #fAnchor */ private Anchor[] fFallbackAnchors; /** * The custom information control creator. * @since 3.0 */ private /+volatile+/ IInformationControlCreator fCustomInformationControlCreator; /** * Tells whether a custom information control is in use. * @since 3.0 */ private bool fIsCustomInformationControl= false; /** * The dialog settings for the control's bounds. * @since 3.0 */ private IDialogSettings fDialogSettings; /** * Tells whether the control's location should be read * from the dialog settings and whether the last * valid control's size is stored back into the settings. * * @since 3.0 */ private bool fIsRestoringLocation; /** * Tells whether the control's size should be read * from the dialog settings and whether the last * valid control's size is stored back into the settings. * * @since 3.0 */ private bool fIsRestoringSize; /** * The dispose listener on the subject control. * * @since 3.1 */ private DisposeListener fSubjectControlDisposeListener; /** * Creates a new information control manager using the given information control creator. * By default the following configuration is given: * <ul> * <li> enabled is false * <li> horizontal margin is 5 points * <li> vertical margin is 5 points * <li> width constraint is 60 characters * <li> height constraint is 6 characters * <li> enforce constraints as minimal size is false * <li> enforce constraints as maximal size is false * <li> layout anchor is ANCHOR_BOTTOM * <li> fall back anchors is { ANCHOR_TOP, ANCHOR_BOTTOM, ANCHOR_LEFT, ANCHOR_RIGHT, ANCHOR_GLOBAL } * <li> takes focus when visible is false * </ul> * * @param creator the information control creator */ protected this(IInformationControlCreator creator) { fAnchor= ANCHOR_BOTTOM(); fFallbackAnchors= ANCHORS(); Assert.isNotNull(cast(Object)creator); fInformationControlCreator= creator; } /** * Computes the information to be displayed and the area in which the computed * information is valid. Implementation of this method must finish their computation * by setting the computation results using <code>setInformation</code>. */ abstract protected void computeInformation(); /** * Sets the parameters of the information to be displayed. These are the information itself and * the area for which the given information is valid. This so called subject area is a graphical * region of the information control's subject control. This method calls <code>presentInformation()</code> * to trigger the presentation of the computed information. * * @param information the information, or <code>null</code> if none is available * @param subjectArea the subject area, or <code>null</code> if none is available */ protected final void setInformation(String information, Rectangle subjectArea) { setInformation(stringcast(information), subjectArea); } /** * Sets the parameters of the information to be displayed. These are the information itself and * the area for which the given information is valid. This so called subject area is a graphical * region of the information control's subject control. This method calls <code>presentInformation()</code> * to trigger the presentation of the computed information. * * @param information the information, or <code>null</code> if none is available * @param subjectArea the subject area, or <code>null</code> if none is available * @since 2.1 */ protected final void setInformation(Object information, Rectangle subjectArea) { fInformation= information; fSubjectArea= subjectArea; presentInformation(); } /** * Sets the information control closer for this manager. * * @param closer the information control closer for this manager */ protected void setCloser(IInformationControlCloser closer) { fInformationControlCloser= closer; } /** * Sets the information control replacer for this manager and disposes the * old one if set. * * @param replacer the information control replacer for this manager, or * <code>null</code> if no information control replacing should * take place * @since 3.4 */ void setInformationControlReplacer(InformationControlReplacer replacer) { if (fInformationControlReplacer !is null) fInformationControlReplacer.dispose(); fInformationControlReplacer= replacer; } /** * Returns the current information control replacer or <code>null</code> if none has been installed. * * @return the current information control replacer or <code>null</code> if none has been installed * @since 3.4 */ InformationControlReplacer getInformationControlReplacer() { return fInformationControlReplacer; } /** * Returns whether an information control replacer has been installed. * * @return whether an information control replacer has been installed * @since 3.4 */ bool hasInformationControlReplacer() { return fInformationControlReplacer !is null; } /** * Tests whether the given information control is replaceable. * * @param iControl information control or <code>null</code> if none * @return <code>true</code> if information control is replaceable, <code>false</code> otherwise * @since 3.4 */ bool canReplace(IInformationControl iControl) { return cast(IInformationControlExtension3)iControl && cast(IInformationControlExtension5)iControl && (cast(IInformationControlExtension5) iControl).getInformationPresenterControlCreator() !is null; } /** * Returns the current information control, or <code>null</code> if none. * * @return the current information control, or <code>null</code> if none * @since 3.4 */ IInformationControl getCurrentInformationControl() { return fInformationControl; } /** * Tells whether this manager's information control is currently being replaced. * * @return <code>true</code> if a replace is in progress * @since 3.4 */ bool isReplaceInProgress() { return fInformationControlReplacer !is null && fInformationControlReplacer.isReplacing(); } /** * Sets the horizontal and vertical margin to be used when laying out the * information control relative to the subject control. * * @param xMargin the x-margin * @param yMargin the y-Margin */ public void setMargins(int xMargin, int yMargin) { fMarginX= xMargin; fMarginY= yMargin; } /** * Sets the width- and height constraints of the information control. * * @param widthInChar the width constraint in number of characters * @param heightInChar the height constrain in number of characters * @param enforceAsMinimalSize indicates whether the constraints describe the minimal allowed size of the control * @param enforceAsMaximalSize indicates whether the constraints describe the maximal allowed size of the control */ public void setSizeConstraints(int widthInChar, int heightInChar, bool enforceAsMinimalSize, bool enforceAsMaximalSize) { fSizeConstraints= null; fWidthConstraint= widthInChar; fHeightConstraint= heightInChar; fEnforceAsMinimalSize= enforceAsMinimalSize; fEnforceAsMaximalSize= enforceAsMaximalSize; } /** * 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 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 AbstractInformationControlManager#STORE_LOCATION_X}</li> * <li>{@link AbstractInformationControlManager#STORE_LOCATION_Y}</li> * <li>{@link AbstractInformationControlManager#STORE_SIZE_WIDTH}</li> * <li>{@link AbstractInformationControlManager#STORE_SIZE_HEIGHT}</li> * </ul> * </p> * * @param dialogSettings * @param restoreLocation <code>true</code> iff the location is must be (re-)stored * @param restoreSize <code>true</code>iff the size is (re-)stored * @since 3.0 */ public void setRestoreInformationControlBounds(IDialogSettings dialogSettings, bool restoreLocation, bool restoreSize) { Assert.isTrue(dialogSettings !is null && (restoreLocation || restoreSize)); fDialogSettings= dialogSettings; fIsRestoringLocation= restoreLocation; fIsRestoringSize= restoreSize; } /** * Sets the anchor used for laying out the information control relative to the * subject control. E.g, using <code>ANCHOR_TOP</code> indicates that the * information control is position above the area for which the information to * be displayed is valid. * * @param anchor the layout anchor */ public void setAnchor(Anchor anchor) { fAnchor= anchor; } /** * Sets the anchors fallback sequence used to layout the information control if the original * anchor can not be used because the information control would not fit in the display client * area. * <p> * The fallback anchor for a given anchor is the one that comes directly after the given anchor or * is the first one in the sequence if the given anchor is the last one in the sequence. * <p> * </p> * Note: This sequence is ignored if the original anchor is not contained in this list. * </p> * * @param fallbackAnchors the array with the anchor fallback sequence * @see #setAnchor(AbstractInformationControlManager.Anchor) */ public void setFallbackAnchors(Anchor[] fallbackAnchors) { if (fallbackAnchors !is null) { fFallbackAnchors= new Anchor[fallbackAnchors.length]; System.arraycopy(fallbackAnchors, 0, fFallbackAnchors, 0, fallbackAnchors.length); } else fFallbackAnchors= null; } /** * Sets the temporary custom control creator, overriding this manager's default information control creator. * * @param informationControlCreator the creator, possibly <code>null</code> * @since 3.0 */ protected void setCustomInformationControlCreator(IInformationControlCreator informationControlCreator) { if (informationControlCreator !is null && cast(IInformationControlCreatorExtension)fCustomInformationControlCreator) { IInformationControlCreatorExtension extension= cast(IInformationControlCreatorExtension) fCustomInformationControlCreator; if (extension.canReplace(informationControlCreator)) return; } fCustomInformationControlCreator= informationControlCreator; } /** * Tells the manager whether it should set the focus to the information control when made visible. * * @param takesFocus <code>true</code> if information control should take focus when made visible */ public void takesFocusWhenVisible(bool takesFocus) { fTakesFocusWhenVisible= takesFocus; } /** * Handles the disposal of the subject control. By default, the information control * is disposed by calling <code>disposeInformationControl</code>. Subclasses may extend * this method. */ protected void handleSubjectControlDisposed() { disposeInformationControl(); } /** * Installs this manager on the given control. The control is now taking the role of * the subject control. This implementation sets the control also as the information * control closer's subject control and automatically enables this manager. * * @param subjectControl the subject control */ public void install(Control subjectControl) { if (fSubjectControl !is null && !fSubjectControl.isDisposed() && fSubjectControlDisposeListener !is null) fSubjectControl.removeDisposeListener(fSubjectControlDisposeListener); fSubjectControl= subjectControl; if (fSubjectControl !is null) fSubjectControl.addDisposeListener(getSubjectControlDisposeListener()); if (fInformationControlCloser !is null) fInformationControlCloser.setSubjectControl(subjectControl); setEnabled(true); fDisposed= false; } /** * Returns the dispose listener which gets added * to the subject control. * * @return the dispose listener * @since 3.1 */ private DisposeListener getSubjectControlDisposeListener() { if (fSubjectControlDisposeListener is null) { fSubjectControlDisposeListener= new class() DisposeListener { public void widgetDisposed(DisposeEvent e) { handleSubjectControlDisposed(); } }; } return fSubjectControlDisposeListener; } /** * Returns the subject control of this manager/information control. * * @return the subject control */ protected Control getSubjectControl() { return fSubjectControl; } /** * Returns the actual subject area. * * @return the actual subject area */ protected Rectangle getSubjectArea() { return fSubjectArea; } /** * Sets the enable state of this manager. * * @param enabled the enable state * @deprecated visibility will be changed to protected */ public void setEnabled(bool enabled) { fEnabled= enabled; } /** * Returns whether this manager is enabled or not. * * @return <code>true</code> if this manager is enabled otherwise <code>false</code> */ protected bool isEnabled() { return fEnabled; } /** * Computes the size constraints of the information control in points based on the * default font of the given subject control as well as the size constraints in character * width. * * @param subjectControl the subject control * @param informationControl the information control whose size constraints are computed * @return the computed size constraints in points */ protected Point computeSizeConstraints(Control subjectControl, IInformationControl informationControl) { if (fSizeConstraints is null) { if ( cast(IInformationControlExtension5)informationControl ) { IInformationControlExtension5 iControl5= cast(IInformationControlExtension5) informationControl; fSizeConstraints= iControl5.computeSizeConstraints(fWidthConstraint, fHeightConstraint); if (fSizeConstraints !is null) return Geometry.copy(fSizeConstraints); } if (subjectControl is null) return null; GC gc= new GC(subjectControl); gc.setFont(subjectControl.getFont()); int width= gc.getFontMetrics().getAverageCharWidth(); int height = gc.getFontMetrics().getHeight(); gc.dispose(); fSizeConstraints= new Point (fWidthConstraint * width, fHeightConstraint * height); } return new Point(fSizeConstraints.x, fSizeConstraints.y); } /** * Computes the size constraints of the information control in points. * * @param subjectControl the subject control * @param subjectArea the subject area * @param informationControl the information control whose size constraints are computed * @return the computed size constraints in points * @since 3.0 */ protected Point computeSizeConstraints(Control subjectControl, Rectangle subjectArea, IInformationControl informationControl) { return computeSizeConstraints(subjectControl, informationControl); } /** * Handles the disposal of the information control. By default, the information * control closer is stopped. */ protected void handleInformationControlDisposed() { storeInformationControlBounds(); if ( cast(IInformationControlExtension5)fInformationControl ) fSizeConstraints= null; fInformationControl= null; if (fInformationControlCloser !is null) { fInformationControlCloser.setInformationControl(null); //XXX: null is against the spec fInformationControlCloser.stop(); } } /** * Returns the information control. If the information control has not been created yet, * it is automatically created. * * @return the information control */ protected IInformationControl getInformationControl() { if (fDisposed) return fInformationControl; IInformationControlCreator creator= null; if (fCustomInformationControlCreator is null) { creator= fInformationControlCreator; if (fIsCustomInformationControl && fInformationControl !is null) { if ( cast(IInformationControlExtension5)fInformationControl ) fSizeConstraints= null; fInformationControl.dispose(); fInformationControl= null; } fIsCustomInformationControl= false; } else { creator= fCustomInformationControlCreator; if ( cast(IInformationControlCreatorExtension)creator ) { IInformationControlCreatorExtension extension= cast(IInformationControlCreatorExtension) creator; if (fInformationControl !is null && extension.canReuse(fInformationControl)) return fInformationControl; } if (fInformationControl !is null) { if ( cast(IInformationControlExtension5)fInformationControl ) fSizeConstraints= null; fInformationControl.dispose(); fInformationControl= null; } fIsCustomInformationControl= true; } if (fInformationControl is null) { fInformationControl= creator.createInformationControl(fSubjectControl.getShell()); fInformationControl.addDisposeListener(new class() DisposeListener { public void widgetDisposed(DisposeEvent e) { handleInformationControlDisposed(); } }); if (fInformationControlCloser !is null) fInformationControlCloser.setInformationControl(fInformationControl); } return fInformationControl; } /** * Computes the display location of the information control. The location is computed * considering the given subject area, the anchor at the subject area, and the * size of the information control. This method does not care about whether the information * control would be completely visible when placed at the result location. * * @param subjectArea the subject area * @param controlSize the size of the information control * @param anchor the anchor at the subject area * @return the display location of the information control */ protected Point computeLocation(Rectangle subjectArea, Point controlSize, Anchor anchor) { int xShift= 0; int yShift= 0; switch (anchor.getSWTFlag()) { case SWT.CENTER: Point subjectControlSize= fSubjectControl.getSize(); Point location= new Point(subjectControlSize.x / 2, subjectControlSize.y / 2); location.x -= (controlSize.x / 2); location.y -= (controlSize.y / 2); return fSubjectControl.toDisplay(location); case SWT.BOTTOM: yShift= subjectArea.height + fMarginY; break; case SWT.RIGHT: xShift= fMarginX + subjectArea.width; break; case SWT.TOP: yShift= -controlSize.y - fMarginY; break; case SWT.LEFT: xShift= -controlSize.x - fMarginX; break; default: } bool isRTL= fSubjectControl !is null && (fSubjectControl.getStyle() & SWT.RIGHT_TO_LEFT) !is 0; if (isRTL) xShift += controlSize.x; return fSubjectControl.toDisplay(new Point(subjectArea.x + xShift, subjectArea.y + yShift)); } /** * Computes the area available for an information control given an anchor and the subject area * within <code>bounds</code>. * * @param subjectArea the subject area * @param bounds the bounds * @param anchor the anchor at the subject area * @return the area available at the given anchor relative to the subject area, confined to the * monitor's client area * @since 3.3 */ protected Rectangle computeAvailableArea(Rectangle subjectArea, Rectangle bounds, Anchor anchor) { Rectangle area; switch (anchor.getSWTFlag()) { case SWT.CENTER: area= bounds; break; case SWT.BOTTOM: int y= subjectArea.y + subjectArea.height + fMarginY; area= new Rectangle(bounds.x, y, bounds.width, bounds.y + bounds.height - y); break; case SWT.RIGHT: int x= subjectArea.x + subjectArea.width + fMarginX; area= new Rectangle(x, bounds.y, bounds.x + bounds.width - x, bounds.height); break; case SWT.TOP: area= new Rectangle(bounds.x, bounds.y, bounds.width, subjectArea.y - bounds.y - fMarginY); break; case SWT.LEFT: area= new Rectangle(bounds.x, bounds.y, subjectArea.x - bounds.x - fMarginX, bounds.height); break; default: Assert.isLegal(false); return null; } // Don't return negative areas if the subjectArea overlaps with the monitor bounds. area.intersect(bounds); return area; } /** * Checks whether a control of the given size at the given location would be completely visible * in the given display area when laid out by using the given anchor. If not, this method tries * to shift the control orthogonal to the direction given by the anchor to make it visible. If possible * it updates the location.<p> * This method returns <code>true</code> if the potentially updated position results in a * completely visible control, or <code>false</code> otherwise. * * * @param location the location of the control * @param size the size of the control * @param displayArea the display area in which the control should be visible * @param anchor anchor for lying out the control * @return <code>true</code>if the updated location is useful */ protected bool updateLocation(Point location, Point size, Rectangle displayArea, Anchor anchor) { int displayLowerRightX= displayArea.x + displayArea.width; int displayLowerRightY= displayArea.y + displayArea.height; int lowerRightX= location.x + size.x; int lowerRightY= location.y + size.y; if (ANCHOR_BOTTOM is anchor || ANCHOR_TOP is anchor) { if (ANCHOR_BOTTOM is anchor) { if (lowerRightY > displayLowerRightY) return false; } else { if (location.y < displayArea.y) return false; } if (lowerRightX > displayLowerRightX) location.x= location.x - (lowerRightX - displayLowerRightX); return (location.x >= displayArea.x && location.y >= displayArea.y); } else if (ANCHOR_RIGHT is anchor || ANCHOR_LEFT is anchor) { if (ANCHOR_RIGHT is anchor) { if (lowerRightX > displayLowerRightX) return false; } else { if (location.x < displayArea.x) return false; } if (lowerRightY > displayLowerRightY) location.y= location.y - (lowerRightY - displayLowerRightY); return (location.x >= displayArea.x && location.y >= displayArea.y); } else if (ANCHOR_GLOBAL is anchor) { if (lowerRightX > displayLowerRightX) location.x= location.x - (lowerRightX - displayLowerRightX); if (lowerRightY > displayLowerRightY) location.y= location.y - (lowerRightY - displayLowerRightY); return (location.x >= displayArea.x && location.y >= displayArea.y); } return false; } /** * Returns the next fallback anchor as specified by this manager's * fallback anchor sequence. * <p> * The fallback anchor for the given anchor is the one that comes directly after * the given anchor or is the first one in the sequence if the given anchor is the * last one in the sequence. * </p> * <p> * Note: It is the callers responsibility to prevent an endless loop i.e. to test * whether a given anchor has already been used once. * then * </p> * * @param anchor the current anchor * @return the next fallback anchor or <code>null</code> if no fallback anchor is available */ protected Anchor getNextFallbackAnchor(Anchor anchor) { if (anchor is null || fFallbackAnchors is null) return null; for (int i= 0; i < fFallbackAnchors.length; i++) { if (fFallbackAnchors[i] is anchor) return fFallbackAnchors[i + 1 is fFallbackAnchors.length ? 0 : i + 1]; } return null; } /** * Computes the location of the information control depending on the * subject area and the size of the information control. This method attempts * to find a location at which the information control lies completely in the display's * client area while honoring the manager's default anchor. If this isn't possible using the * default anchor, the fallback anchors are tried out. * * @param subjectArea the information area * @param controlSize the size of the information control * @return the computed location of the information control */ protected Point computeInformationControlLocation(Rectangle subjectArea, Point controlSize) { Rectangle subjectAreaDisplayRelative= Geometry.toDisplay(fSubjectControl, subjectArea); Point upperLeft; Anchor testAnchor= fAnchor; Rectangle bestBounds= null; int bestArea= Integer.MIN_VALUE; Anchor bestAnchor= null; do { upperLeft= computeLocation(subjectArea, controlSize, testAnchor); org.eclipse.swt.widgets.Monitor.Monitor monitor= getClosestMonitor(subjectAreaDisplayRelative, testAnchor); if (updateLocation(upperLeft, controlSize, monitor.getClientArea(), testAnchor)) return upperLeft; // compute available area for this anchor and update if better than best Rectangle available= computeAvailableArea(subjectAreaDisplayRelative, monitor.getClientArea(), testAnchor); Rectangle proposed= new Rectangle(upperLeft.x, upperLeft.y, controlSize.x, controlSize.y); available.intersect(proposed); int area= available.width * available.height; if (area > bestArea) { bestArea= area; bestBounds= available; bestAnchor= testAnchor; } testAnchor= getNextFallbackAnchor(testAnchor); } while (testAnchor !is fAnchor && testAnchor !is null); // no anchor is perfect - select the one with larges area and set the size to not overlap with the subjectArea if (bestAnchor !is ANCHOR_GLOBAL) Geometry.set(controlSize, Geometry.getSize(bestBounds)); return Geometry.getLocation(bestBounds); } /** * Gets the closest monitor given an anchor and the subject area. * * @param area the subject area * @param anchor the anchor * @return the monitor closest to the edge of <code>area</code> defined by * <code>anchor</code> * @since 3.3 */ private org.eclipse.swt.widgets.Monitor.Monitor getClosestMonitor(Rectangle area, Anchor anchor) { Point center; if (ANCHOR_GLOBAL is anchor) center= Geometry.centerPoint(area); else center= Geometry.centerPoint(Geometry.getExtrudedEdge(area, 0, anchor.getSWTFlag())); return getClosestMonitor(fSubjectControl.getDisplay(), Geometry.createRectangle(center, new Point(0, 0))); } /** * 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 display the display to search for monitors * @param rectangle the rectangle to find the closest monitor for (display coordinates) * @return the monitor closest to the given point * @since 3.3 */ private org.eclipse.swt.widgets.Monitor.Monitor getClosestMonitor(Display display, Rectangle rectangle) { int closest = Integer.MAX_VALUE; Point toFind= Geometry.centerPoint(rectangle); org.eclipse.swt.widgets.Monitor.Monitor[] monitors = display.getMonitors(); org.eclipse.swt.widgets.Monitor.Monitor result = monitors[0]; for (int idx = 0; idx < monitors.length; idx++) { org.eclipse.swt.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; } /** * Computes information to be displayed as well as the subject area * and initiates that this information is presented in the information control. * This happens only if this controller is enabled. */ public void showInformation() { if (fEnabled) doShowInformation(); } /** * Computes information to be displayed as well as the subject area * and initiates that this information is presented in the information control. */ protected void doShowInformation() { fSubjectArea= null; fInformation= null; computeInformation(); } /** * Presents the information in the information control or hides the information * control if no information should be presented. The information has previously * been set using <code>setInformation</code>. */ protected void presentInformation() { bool hasContents= false; if ( stringcast(fInformation) ) hasContents= (stringcast(fInformation)).trim().length() > 0; else hasContents= (fInformation !is null); if (fSubjectArea !is null && hasContents) internalShowInformationControl(fSubjectArea, fInformation); else hideInformationControl(); } /** * Opens the information control with the given information and the specified * subject area. It also activates the information control closer. * * @param subjectArea the information area * @param information the information */ private void internalShowInformationControl(Rectangle subjectArea, Object information) { if ( cast(InformationControlReplacer)this ) { (cast(InformationControlReplacer) this).showInformationControl(subjectArea, information); return; } IInformationControl informationControl= getInformationControl(); if (informationControl !is null) { Point sizeConstraints= computeSizeConstraints(fSubjectControl, fSubjectArea, informationControl); if ( cast(IInformationControlExtension3)informationControl ) { IInformationControlExtension3 iControl3= cast(IInformationControlExtension3) informationControl; Rectangle trim= iControl3.computeTrim(); sizeConstraints.x += trim.width; sizeConstraints.y += trim.height; } informationControl.setSizeConstraints(sizeConstraints.x, sizeConstraints.y); if ( cast(IInformationControlExtension2)informationControl ) (cast(IInformationControlExtension2)informationControl).setInput(information); else informationControl.setInformation(information.toString()); if ( cast(IInformationControlExtension)informationControl ) { IInformationControlExtension extension= cast(IInformationControlExtension)informationControl; if (!extension.hasContents()) return; } Point size= null; Point location= null; Rectangle bounds= restoreInformationControlBounds(); if (bounds !is null) { if (bounds.x > -1 && bounds.y > -1) location= Geometry.getLocation(bounds); if (bounds.width > -1 && bounds.height > -1) size= Geometry.getSize(bounds); } if (size is null) size= informationControl.computeSizeHint(); if (fEnforceAsMinimalSize) size= Geometry.max(size, sizeConstraints); if (fEnforceAsMaximalSize) size= Geometry.min(size, sizeConstraints); if (location is null) location= computeInformationControlLocation(subjectArea, size); Rectangle controlBounds= Geometry.createRectangle(location, size); cropToClosestMonitor(controlBounds); location= Geometry.getLocation(controlBounds); size= Geometry.getSize(controlBounds); informationControl.setLocation(location); informationControl.setSize(size.x, size.y); showInformationControl(subjectArea); } } /** * Crops the given bounds such that they lie completely on the closest monitor. * * @param bounds shell bounds to crop * @since 3.4 */ void cropToClosestMonitor(Rectangle bounds) { Rectangle monitorBounds= getClosestMonitor(fSubjectControl.getDisplay(), bounds).getClientArea(); bounds.intersect(monitorBounds); } /** * Hides the information control and stops the information control closer. */ protected void hideInformationControl() { if (fInformationControl !is null) { storeInformationControlBounds(); fInformationControl.setVisible(false); if (fInformationControlCloser !is null) fInformationControlCloser.stop(); } } /** * Shows the information control and starts the information control closer. * This method may not be called by clients. * * @param subjectArea the information area */ protected void showInformationControl(Rectangle subjectArea) { fInformationControl.setVisible(true); if (fTakesFocusWhenVisible) fInformationControl.setFocus(); if (fInformationControlCloser !is null) fInformationControlCloser.start(subjectArea); } /** * Replaces this manager's information control as defined by * the information control replacer. * <strong>Must only be called when {@link #fInformationControl} instanceof {@link IInformationControlExtension3}!</strong> * * @param takeFocus <code>true</code> iff the replacing information control should take focus * * @since 3.4 */ void replaceInformationControl(bool takeFocus) { if (fInformationControlReplacer !is null && canReplace(fInformationControl)) { IInformationControlExtension3 iControl3= cast(IInformationControlExtension3) fInformationControl; Rectangle b= iControl3.getBounds(); Rectangle t= iControl3.computeTrim(); Rectangle contentBounds= new Rectangle(b.x - t.x, b.y - t.y, b.width - t.width, b.height - t.height); IInformationControlCreator informationPresenterControlCreator= (cast(IInformationControlExtension5) fInformationControl).getInformationPresenterControlCreator(); fInformationControlReplacer.replaceInformationControl(informationPresenterControlCreator, contentBounds, fInformation, fSubjectArea, takeFocus); } hideInformationControl(); } /** * Disposes this manager's information control. */ public void disposeInformationControl() { if (fInformationControl !is null) { fInformationControl.dispose(); handleInformationControlDisposed(); } } /** * Disposes this manager and if necessary all dependent parts such as * the information control. For symmetry it first disables this manager. */ public void dispose() { if (!fDisposed) { fDisposed= true; setEnabled(false); disposeInformationControl(); if (fInformationControlReplacer !is null) { fInformationControlReplacer.dispose(); fInformationControlReplacer= null; } if (fSubjectControl !is null && !fSubjectControl.isDisposed() && fSubjectControlDisposeListener !is null) fSubjectControl.removeDisposeListener(fSubjectControlDisposeListener); fSubjectControl= null; fSubjectControlDisposeListener= null; fIsCustomInformationControl= false; fCustomInformationControlCreator= null; fInformationControlCreator= null; fInformationControlCloser= null; } } // ------ control's size handling dialog settings ------ /** * Stores the information control's bounds. * * @since 3.0 */ protected void storeInformationControlBounds() { if (fDialogSettings is null || fInformationControl is null || !(fIsRestoringLocation || fIsRestoringSize)) return; if (!( cast(IInformationControlExtension3)fInformationControl )) throw new UnsupportedOperationException(); bool controlRestoresSize= (cast(IInformationControlExtension3)fInformationControl).restoresSize(); bool controlRestoresLocation= (cast(IInformationControlExtension3)fInformationControl).restoresLocation(); Rectangle bounds= (cast(IInformationControlExtension3)fInformationControl).getBounds(); if (bounds is null) return; if (fIsRestoringSize && controlRestoresSize) { fDialogSettings.put(STORE_SIZE_WIDTH, bounds.width); fDialogSettings.put(STORE_SIZE_HEIGHT, bounds.height); } if (fIsRestoringLocation && controlRestoresLocation) { fDialogSettings.put(STORE_LOCATION_X, bounds.x); fDialogSettings.put(STORE_LOCATION_Y, bounds.y); } } /** * Restores the information control's bounds. * * @return the stored bounds * @since 3.0 */ protected Rectangle restoreInformationControlBounds() { if (fDialogSettings is null || !(fIsRestoringLocation || fIsRestoringSize)) return null; if (!( cast(IInformationControlExtension3)fInformationControl )) throw new UnsupportedOperationException(); bool controlRestoresSize= (cast(IInformationControlExtension3)fInformationControl).restoresSize(); bool controlRestoresLocation= (cast(IInformationControlExtension3)fInformationControl).restoresLocation(); Rectangle bounds= new Rectangle(-1, -1, -1, -1); if (fIsRestoringSize && controlRestoresSize) { try { bounds.width= fDialogSettings.getInt(STORE_SIZE_WIDTH); bounds.height= fDialogSettings.getInt(STORE_SIZE_HEIGHT); } catch (NumberFormatException ex) { bounds.width= -1; bounds.height= -1; } } if (fIsRestoringLocation && controlRestoresLocation) { try { bounds.x= fDialogSettings.getInt(STORE_LOCATION_X); bounds.y= fDialogSettings.getInt(STORE_LOCATION_Y); } catch (NumberFormatException ex) { bounds.x= -1; bounds.y= -1; } } // sanity check if (bounds.x is -1 && bounds.y is -1 && bounds.width is -1 && bounds.height is -1) return null; Rectangle maxBounds= null; if (fSubjectControl !is null && !fSubjectControl.isDisposed()) maxBounds= fSubjectControl.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 (bounds.width > -1 && bounds.height > -1) { if (maxBounds !is null) { bounds.width= Math.min(bounds.width, maxBounds.width); bounds.height= Math.min(bounds.height, maxBounds.height); } // Enforce an absolute minimal size bounds.width= Math.max(bounds.width, 30); bounds.height= Math.max(bounds.height, 30); } if (bounds.x > -1 && bounds.y > -1 && maxBounds !is null) { bounds.x= Math.max(bounds.x, maxBounds.x); bounds.y= Math.max(bounds.y, maxBounds.y); if (bounds .width > -1 && bounds.height > -1) { bounds.x= Math.min(bounds.x, maxBounds.width - bounds.width); bounds.y= Math.min(bounds.y, maxBounds.height - bounds.height); } } return bounds; } /** * Returns an adapter that gives access to internal methods. * <p> * <strong>Note:</strong> This method is not intended to be referenced or overridden by clients.</p> * * @return the replaceable information control accessor * @since 3.4 * @noreference This method is not intended to be referenced by clients. * @nooverride This method is not intended to be re-implemented or extended by clients. */ public InternalAccessor getInternalAccessor() { return new MyInternalAccessor(this); } }