/*
* Copyright (c) 2011, the Dart project authors.
*
* Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.eclipse.org/legal/epl-v10.html
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.dart.tools.ui.omni;
import com.google.dart.tools.ui.internal.util.SWTUtil;
import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.GroupMarker;
import org.eclipse.jface.action.IAction;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.dialogs.Dialog;
import org.eclipse.jface.dialogs.IDialogSettings;
import org.eclipse.jface.dialogs.PopupDialog;
import org.eclipse.jface.layout.GridDataFactory;
import org.eclipse.jface.layout.GridLayoutFactory;
import org.eclipse.jface.resource.JFaceResources;
import org.eclipse.jface.util.Util;
import org.eclipse.jface.window.Window;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.DisposeEvent;
import org.eclipse.swt.events.DisposeListener;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Menu;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.ToolBar;
import org.eclipse.swt.widgets.ToolItem;
import org.eclipse.swt.widgets.Tracker;
import java.util.ArrayList;
import java.util.List;
/**
* A modified {@link PopupDialog} for use in the omnibox.
*/
public class BasePopupDialog extends Window {
/**
* Move action for the dialog.
*/
private class MoveAction extends Action {
MoveAction() {
super(JFaceResources.getString("PopupDialog.move"), //$NON-NLS-1$
IAction.AS_PUSH_BUTTON);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.action.IAction#run()
*/
@Override
public void run() {
performTrackerAction(SWT.NONE);
}
}
/**
* Remember bounds action for the dialog.
*/
private class PersistBoundsAction extends Action {
PersistBoundsAction() {
super(JFaceResources.getString("BasePopupDialog.persistBounds"), //$NON-NLS-1$
IAction.AS_CHECK_BOX);
setChecked(persistLocation && persistSize);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.action.IAction#run()
*/
@Override
public void run() {
persistSize = isChecked();
persistLocation = persistSize;
}
}
/**
* Remember location action for the dialog.
*/
private class PersistLocationAction extends Action {
PersistLocationAction() {
super(JFaceResources.getString("BasePopupDialog.persistLocation"), //$NON-NLS-1$
IAction.AS_CHECK_BOX);
setChecked(persistLocation);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.action.IAction#run()
*/
@Override
public void run() {
persistLocation = isChecked();
}
}
/**
* Remember bounds action for the dialog.
*/
private class PersistSizeAction extends Action {
PersistSizeAction() {
super(JFaceResources.getString("BasePopupDialog.persistSize"), //$NON-NLS-1$
IAction.AS_CHECK_BOX);
setChecked(persistSize);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.action.IAction#run()
*/
@Override
public void run() {
persistSize = isChecked();
}
}
/**
* Resize action for the dialog.
*/
private class ResizeAction extends Action {
ResizeAction() {
super(JFaceResources.getString("BasePopupDialog.resize"), //$NON-NLS-1$
IAction.AS_PUSH_BUTTON);
}
/*
* @see org.eclipse.jface.action.Action#run()
*/
@Override
public void run() {
performTrackerAction(SWT.RESIZE);
}
}
/**
*
*/
private static GridDataFactory grabBothGridDataFactory;
/**
* The dialog settings key name for stored dialog x location.
*/
private static final String DIALOG_ORIGIN_X = "DIALOG_X_ORIGIN"; //$NON-NLS-1$
/**
* The dialog settings key name for stored dialog y location.
*/
private static final String DIALOG_ORIGIN_Y = "DIALOG_Y_ORIGIN"; //$NON-NLS-1$
/**
* The dialog settings key name for stored dialog width.
*/
private static final String DIALOG_WIDTH = "DIALOG_WIDTH"; //$NON-NLS-1$
/**
* The dialog settings key name for stored dialog height.
*/
private static final String DIALOG_HEIGHT = "DIALOG_HEIGHT"; //$NON-NLS-1$
/**
* The dialog settings key name for remembering if the persisted bounds should be accessed.
*
* @deprecated Since 3.4, this is retained only for backward compatibility.
*/
@Deprecated
private static final String DIALOG_USE_PERSISTED_BOUNDS = "DIALOG_USE_PERSISTED_BOUNDS"; //$NON-NLS-1$
/**
* The dialog settings key name for remembering if the bounds persisted prior to 3.4 have been
* migrated to the 3.4 settings.
*
* @since 3.4
* @deprecated This is marked deprecated at its introduction to discourage future dependency
*/
@Deprecated
private static final String DIALOG_VALUE_MIGRATED_TO_34 = "hasBeenMigratedTo34"; //$NON-NLS-1$
/**
* The dialog settings key name for remembering if the persisted size should be accessed.
*/
private static final String DIALOG_USE_PERSISTED_SIZE = "DIALOG_USE_PERSISTED_SIZE"; //$NON-NLS-1$
/**
* The dialog settings key name for remembering if the persisted location should be accessed.
*/
private static final String DIALOG_USE_PERSISTED_LOCATION = "DIALOG_USE_PERSISTED_LOCATION"; //$NON-NLS-1$
/**
* Shell style appropriate for a simple hover popup that cannot get focus.
*/
public final static int HOVER_SHELLSTYLE = SWT.NO_FOCUS | SWT.ON_TOP | SWT.TOOL;
/**
* Shell style appropriate for an info popup that can get focus.
*/
public final static int INFOPOPUP_SHELLSTYLE = SWT.TOOL;
/**
* Shell style appropriate for a resizable info popup that can get focus.
*/
public final static int INFOPOPUPRESIZE_SHELLSTYLE = SWT.RESIZE;
/**
* Margin width (in pixels) to be used in layouts inside popup dialogs (value is 0).
*/
public final static int POPUP_MARGINWIDTH = 0;
/**
* Margin height (in pixels) to be used in layouts inside popup dialogs (value is 0).
*/
public final static int POPUP_MARGINHEIGHT = 0;
/**
* Vertical spacing (in pixels) between cells in the layouts inside popup dialogs (value is 1).
*/
public final static int POPUP_VERTICALSPACING = 1;
/**
* Vertical spacing (in pixels) between cells in the layouts inside popup dialogs (value is 1).
*/
public final static int POPUP_HORIZONTALSPACING = 1;
/**
* Image registry key for menu image.
*
* @since 3.4
*/
public static final String POPUP_IMG_MENU = "popup_menu_image"; //$NON-NLS-1$
/**
* Image registry key for disabled menu image.
*
* @since 3.4
*/
public static final String POPUP_IMG_MENU_DISABLED = "popup_menu_image_diabled"; //$NON-NLS-1$
/**
*
*/
private static GridLayoutFactory popupLayoutFactory;
/**
* Returns an RGB that lies between the given foreground and background colors using the given
* mixing factor. A <code>factor</code> of 1.0 will produce a color equal to <code>fg</code>,
* while a <code>factor</code> of 0.0 will produce one equal to <code>bg</code>.
*
* @param bg the background color
* @param fg the foreground color
* @param factor the mixing factor, must be in [0, 1]
* @return the interpolated color
* @since 3.6
*/
private static RGB blend(RGB bg, RGB fg, float factor) {
// copy of org.eclipse.jface.internal.text.revisions.Colors#blend(..)
Assert.isLegal(bg != null);
Assert.isLegal(fg != null);
Assert.isLegal(factor >= 0f && factor <= 1f);
float complement = 1f - factor;
return new RGB(
(int) (complement * bg.red + factor * fg.red),
(int) (complement * bg.green + factor * fg.green),
(int) (complement * bg.blue + factor * fg.blue));
}
private static GridDataFactory getGrabBothGridData() {
if (grabBothGridDataFactory == null) {
grabBothGridDataFactory = GridDataFactory.fillDefaults().grab(true, true);
}
return grabBothGridDataFactory;
}
private static GridLayoutFactory getPopupLayout() {
if (popupLayoutFactory == null) {
popupLayoutFactory = GridLayoutFactory.fillDefaults().margins(
POPUP_MARGINWIDTH,
POPUP_MARGINHEIGHT).spacing(POPUP_HORIZONTALSPACING, POPUP_VERTICALSPACING);
}
return popupLayoutFactory;
}
/**
* The dialog's toolbar for the move and resize capabilities.
*/
private ToolBar toolBar = null;
/**
* The dialog's menu manager.
*/
private MenuManager menuManager = null;
/**
* The control representing the main dialog area.
*/
private Control dialogArea;
/**
* Labels that contain title and info text. Cached so they can be updated dynamically if possible.
*/
private Label titleLabel, infoLabel;
/**
* Separator controls. Cached so they can be excluded from color changes.
*/
private Control titleSeparator, infoSeparator;
/**
* Color to be used for the info area text.
*
* @since 3.6
*/
private Color infoColor;
/**
* Font to be used for the info area text. Computed based on the dialog's font.
*/
private Font infoFont;
/**
* Font to be used for the title area text. Computed based on the dialog's font.
*/
private Font titleFont;
/**
* Flags indicating whether we are listening for shell deactivate events, either those or our
* parent's. Used to prevent closure when a menu command is chosen or a secondary popup is
* launched.
*/
private boolean listenToDeactivate;
private boolean listenToParentDeactivate;
private Listener parentDeactivateListener;
/**
* Flag indicating whether focus should be taken when the dialog is opened.
*/
private boolean takeFocusOnOpen = false;
/**
* Flag specifying whether a menu should be shown that allows the user to move and resize.
*/
private boolean showDialogMenu = false;
/**
* Flag specifying whether menu actions allowing the user to choose whether the dialog bounds and
* location should be persisted are to be shown.
*/
private boolean showPersistActions = false;
/**
* Flag specifying whether the size of the popup should be persisted. This flag is used as initial
* default and updated by the menu if it is shown.
*/
private boolean persistSize = false;
/**
* Flag specifying whether the location of the popup should be persisted. This flag is used as
* initial default and updated by the menu if it is shown.
*/
private boolean persistLocation = false;
/**
* Flag specifying whether to use new 3.4 API instead of the old one.
*
* @since 3.4
*/
private boolean isUsing34API = true;
/**
* Text to be shown in an optional title area (on top).
*/
private String titleText;
/**
* Text to be shown in an optional info area (at the bottom).
*/
private String infoText;
/**
* Constructs a new instance of <code>BasePopupDialog</code>.
*
* @param parent The parent shell.
* @param shellStyle The shell style.
* @param takeFocusOnOpen A boolean indicating whether focus should be taken by this popup when it
* opens.
* @param persistSize A boolean indicating whether the size should be persisted upon close of the
* dialog. The size can only be persisted if the dialog settings for persisting the
* bounds are also specified. If a menu action will be provided that allows the user to
* control this feature and the user hasn't changed that setting, then this flag is used
* as initial default for the menu.
* @param persistLocation A boolean indicating whether the location should be persisted upon close
* of the dialog. The location can only be persisted if the dialog settings for
* persisting the bounds are also specified. If a menu action will be provided that
* allows the user to control this feature and the user hasn't changed that setting, then
* this flag is used as initial default for the menu. default for the menu until the user
* changed it.
* @param showDialogMenu A boolean indicating whether a menu for moving and resizing the popup
* should be provided.
* @param showPersistActions A boolean indicating whether actions allowing the user to control the
* persisting of the dialog bounds and location should be shown in the dialog menu. This
* parameter has no effect if <code>showDialogMenu</code> is <code>false</code>.
* @param titleText Text to be shown in an upper title area, or <code>null</code> if there is no
* title.
* @param infoText Text to be shown in a lower info area, or <code>null</code> if there is no info
* area.
* @see BasePopupDialog#getDialogSettings()
* @since 3.4
*/
public BasePopupDialog(Shell parent, int shellStyle, boolean takeFocusOnOpen,
boolean persistSize, boolean persistLocation, boolean showDialogMenu,
boolean showPersistActions, String titleText, String infoText) {
this(
parent,
shellStyle,
takeFocusOnOpen,
persistSize,
persistLocation,
showDialogMenu,
showPersistActions,
titleText,
infoText,
true);
}
/**
* Constructs a new instance of <code>BasePopupDialog</code>.
*
* @param parent The parent shell.
* @param shellStyle The shell style.
* @param takeFocusOnOpen A boolean indicating whether focus should be taken by this popup when it
* opens.
* @param persistBounds A boolean indicating whether the bounds (size and location) of the dialog
* should be persisted upon close of the dialog. The bounds can only be persisted if the
* dialog settings for persisting the bounds are also specified. If a menu action will be
* provided that allows the user to control this feature, then the last known value of
* the user's setting will be used instead of this flag.
* @param showDialogMenu A boolean indicating whether a menu for moving and resizing the popup
* should be provided.
* @param showPersistActions A boolean indicating whether actions allowing the user to control the
* persisting of the dialog size and location should be shown in the dialog menu. This
* parameter has no effect if <code>showDialogMenu</code> is <code>false</code>.
* @param titleText Text to be shown in an upper title area, or <code>null</code> if there is no
* title.
* @param infoText Text to be shown in a lower info area, or <code>null</code> if there is no info
* area.
* @see BasePopupDialog#getDialogSettings()
* @deprecated As of 3.4, replaced by
* {@link #BasePopupDialog(Shell, int, boolean, boolean, boolean, boolean, boolean, String, String)}
*/
@Deprecated
public BasePopupDialog(Shell parent, int shellStyle, boolean takeFocusOnOpen,
boolean persistBounds, boolean showDialogMenu, boolean showPersistActions, String titleText,
String infoText) {
this(
parent,
shellStyle,
takeFocusOnOpen,
persistBounds,
persistBounds,
showDialogMenu,
showPersistActions,
titleText,
infoText,
false);
}
/**
* Constructs a new instance of <code>BasePopupDialog</code>.
*
* @param parent The parent shell.
* @param shellStyle The shell style.
* @param takeFocusOnOpen A boolean indicating whether focus should be taken by this popup when it
* opens.
* @param persistSize A boolean indicating whether the size should be persisted upon close of the
* dialog. The size can only be persisted if the dialog settings for persisting the
* bounds are also specified. If a menu action will be provided that allows the user to
* control this feature and the user hasn't changed that setting, then this flag is used
* as initial default for the menu.
* @param persistLocation A boolean indicating whether the location should be persisted upon close
* of the dialog. The location can only be persisted if the dialog settings for
* persisting the bounds are also specified. If a menu action will be provided that
* allows the user to control this feature and the user hasn't changed that setting, then
* this flag is used as initial default for the menu. default for the menu until the user
* changed it.
* @param showDialogMenu A boolean indicating whether a menu for moving and resizing the popup
* should be provided.
* @param showPersistActions A boolean indicating whether actions allowing the user to control the
* persisting of the dialog bounds and location should be shown in the dialog menu. This
* parameter has no effect if <code>showDialogMenu</code> is <code>false</code>.
* @param titleText Text to be shown in an upper title area, or <code>null</code> if there is no
* title.
* @param infoText Text to be shown in a lower info area, or <code>null</code> if there is no info
* area.
* @param use34API <code>true</code> if 3.4 API should be used
* @see BasePopupDialog#getDialogSettings()
* @since 3.4
*/
private BasePopupDialog(Shell parent, int shellStyle, boolean takeFocusOnOpen,
boolean persistSize, boolean persistLocation, boolean showDialogMenu,
boolean showPersistActions, String titleText, String infoText, boolean use34API) {
super(parent);
// Prior to 3.4, we encouraged use of SWT.NO_TRIM and provided a
// border using a black composite background and margin. Now we
// use SWT.TOOL to get the border for some cases and this conflicts
// with SWT.NO_TRIM. Clients who previously have used SWT.NO_TRIM
// and still had a border drawn for them would find their border go
// away unless we do the following:
// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=219743
if ((shellStyle & SWT.NO_TRIM) != 0) {
shellStyle &= ~(SWT.NO_TRIM | SWT.SHELL_TRIM);
}
setShellStyle(shellStyle);
this.takeFocusOnOpen = takeFocusOnOpen;
this.showDialogMenu = showDialogMenu;
this.showPersistActions = showPersistActions;
this.titleText = titleText;
this.infoText = infoText;
setBlockOnOpen(false);
this.isUsing34API = use34API;
this.persistSize = persistSize;
this.persistLocation = persistLocation;
migrateBoundsSetting();
initializeWidgetState();
}
/**
* Closes this window, disposes its shell, and removes this window from its window manager (if it
* has one).
* <p>
* This method is extended to save the dialog bounds and initialize widget state so that the
* widgets can be recreated if the dialog is reopened. This method may be extended (
* <code>super.close</code> must be called).
* </p>
*
* @return <code>true</code> if the window is (or was already) closed, and <code>false</code> if
* it is still open
*/
@Override
public boolean close() {
// If already closed, there is nothing to do.
// See https://bugs.eclipse.org/bugs/show_bug.cgi?id=127505
if (getShell() == null || getShell().isDisposed()) {
return true;
}
saveDialogBounds(getShell());
// Widgets are about to be disposed, so null out any state
// related to them that was not handled in dispose listeners.
// We do this before disposal so that any received activate or
// deactivate events are duly ignored.
initializeWidgetState();
if (parentDeactivateListener != null) {
getShell().getParent().removeListener(SWT.Deactivate, parentDeactivateListener);
parentDeactivateListener = null;
}
return super.close();
}
/**
* Opens this window, creating it first if it has not yet been created.
* <p>
* This method is reimplemented for special configuration of PopupDialogs. It never blocks on
* open, immediately returning <code>OK</code> if the open is successful, or <code>CANCEL</code>
* if it is not. It provides framework hooks that allow subclasses to set the focus and tab order,
* and avoids the use of <code>shell.open()</code> in cases where the focus should not be given to
* the shell initially.
*
* @return the return code
* @see org.eclipse.jface.window.Window#open()
*/
@Override
public int open() {
Shell shell = getShell();
if (shell == null || shell.isDisposed()) {
shell = null;
// create the window
create();
shell = getShell();
}
// provide a hook for adjusting the bounds. This is only
// necessary when there is content driven sizing that must be
// adjusted each time the dialog is opened.
adjustBounds();
// limit the shell size to the display size
constrainShellSize();
// set up the tab order for the dialog
setTabOrder((Composite) getContents());
// initialize flags for listening to deactivate
listenToDeactivate = false;
listenToParentDeactivate = false;
// open the window
if (takeFocusOnOpen) {
shell.open();
getFocusControl().setFocus();
} else {
shell.setVisible(true);
}
return OK;
}
/**
* Adjust the bounds of the popup as necessary prior to opening the dialog. Default is to do
* nothing, which honors any bounds set directly by clients or those that have been saved in the
* dialog settings. Subclasses should override this method when there are bounds computations that
* must be checked each time the dialog is opened.
*/
protected void adjustBounds() {
}
/**
* Set the specified background color for the specified control and all of its children.
* Subclasses may override this method, but typically do not. If a subclass wishes to exclude a
* particular control in its contents from getting the specified background color, it may instead
* override {@link #getBackgroundColorExclusions()}
*
* @param color the color to use as the background color
* @param control the control whose color is to be changed
* @see BasePopupDialog#getBackgroundColorExclusions()
*/
protected void applyBackgroundColor(Color color, Control control) {
applyBackgroundColor(color, control, getBackgroundColorExclusions());
}
/**
* Set the specified foreground color for the specified control and all of its children.
* Subclasses may override this method, but typically do not. If a subclass wishes to exclude a
* particular control in its contents from getting the specified foreground color, it may instead
* override {@link #getForegroundColorExclusions()}.
*
* @param color the color to use as the foreground color
* @param control the control whose color is to be changed
* @see BasePopupDialog#getForegroundColorExclusions()
*/
protected void applyForegroundColor(Color color, Control control) {
applyForegroundColor(color, control, getForegroundColorExclusions());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.window.Window#configureShell(Shell)
*/
@Override
protected void configureShell(Shell shell) {
GridLayoutFactory.fillDefaults().margins(0, 0).spacing(5, 5).applyTo(shell);
shell.addListener(SWT.Deactivate, new Listener() {
@Override
public void handleEvent(Event event) {
/*
* Close if we are deactivating and have no child shells. If we have child shells, we are
* deactivating due to their opening. On X, we receive this when a menu child (such as the
* system menu) of the shell opens, but I have not found a way to distinguish that case
* here. Hence bug #113577 still exists.
*/
if (listenToDeactivate && event.widget == getShell() && getShell().getShells().length == 0) {
asyncClose();
} else {
/*
* We typically ignore deactivates to work around platform-specific event ordering. Now
* that we've ignored whatever we were supposed to, start listening to deactivates.
* Example issues can be found in https://bugs.eclipse.org/bugs/show_bug.cgi?id=123392
*/
if (!Util.isLinux()) {
listenToDeactivate = true;
}
}
}
});
// Set this true whenever we activate. It may have been turned
// off by a menu or secondary popup showing.
shell.addListener(SWT.Activate, new Listener() {
@Override
public void handleEvent(Event event) {
//TODO (pquitslund): in progress...
// // ignore this event if we have launched a child
// if (event.widget == getShell() && getShell().getShells().length == 0) {
// listenToDeactivate = true;
// // Typically we start listening for parent deactivate after
// // we are activated, except on the Mac, where the deactivate
// // is received after activate.
// // See https://bugs.eclipse.org/bugs/show_bug.cgi?id=100668
// listenToParentDeactivate = !Util.isMac();
// }
}
});
if ((getShellStyle() & SWT.ON_TOP) != 0 && shell.getParent() != null) {
parentDeactivateListener = new Listener() {
@Override
public void handleEvent(Event event) {
if (listenToParentDeactivate) {
asyncClose();
} else {
// Our first deactivate, now start listening on the Mac.
listenToParentDeactivate = listenToDeactivate;
}
}
};
shell.getParent().addListener(SWT.Deactivate, parentDeactivateListener);
}
shell.addDisposeListener(new DisposeListener() {
@Override
public void widgetDisposed(DisposeEvent event) {
handleDispose();
}
});
}
/**
* The <code>BasePopupDialog</code> implementation of this <code>Window</code> method creates and
* lays out the top level composite for the dialog. It then calls the
* <code>createTitleMenuArea</code>, <code>createDialogArea</code>, and
* <code>createInfoTextArea</code> methods to create an optional title and menu area on the top, a
* dialog area in the center, and an optional info text area at the bottom. Overriding
* <code>createDialogArea</code> and (optionally) <code>createTitleMenuArea</code> and
* <code>createTitleMenuArea</code> are recommended rather than overriding this method.
*
* @param parent the composite used to parent the contents.
* @return the control representing the contents.
*/
@Override
protected Control createContents(Composite parent) {
Composite composite = new Composite(parent, SWT.NONE);
getPopupLayout().applyTo(composite);
getGrabBothGridData().applyTo(composite);
// Title area
if (hasTitleArea()) {
createTitleMenuArea(composite);
titleSeparator = createHorizontalSeparator(composite);
}
// Content
dialogArea = createDialogArea(composite);
// Create a grid data layout data if one was not provided.
// See https://bugs.eclipse.org/bugs/show_bug.cgi?id=118025
if (dialogArea.getLayoutData() == null) {
getGrabBothGridData().applyTo(dialogArea);
}
// Info field
if (hasInfoArea()) {
infoSeparator = createHorizontalSeparator(composite);
createInfoTextArea(composite);
}
applyColors(composite);
applyFonts(composite);
return composite;
}
/**
* Creates and returns the contents of the dialog (the area below the title area and above the
* info text area.
* <p>
* The <code>BasePopupDialog</code> implementation of this framework method creates and returns a
* new <code>Composite</code> with standard margins and spacing.
* <p>
* The returned control's layout data must be an instance of <code>GridData</code>. This method
* must not modify the parent's layout.
* <p>
* Subclasses must override this method but may call <code>super</code> as in the following
* example:
*
* <pre>
* Composite composite = (Composite) super.createDialogArea(parent);
* //add controls to composite as necessary
* return composite;
* </pre>
*
* @param parent the parent composite to contain the dialog area
* @return the dialog area control
*/
protected Control createDialogArea(Composite parent) {
Composite composite = new Composite(parent, SWT.NONE);
getPopupLayout().applyTo(composite);
getGrabBothGridData().applyTo(composite);
return composite;
}
/**
* Creates the optional info text area. This method is only called if the
* <code>hasInfoArea()</code> method returns true. Subclasses typically need not override this
* method, but may do so.
* <p>
* If this method is overridden, the returned control's layout data must be an instance of
* <code>GridData</code>. This method must not modify the parent's layout.
*
* @param parent The parent composite.
* @return The control representing the info text area.
* @see BasePopupDialog#hasInfoArea()
* @see BasePopupDialog#createTitleControl(Composite)
*/
protected Control createInfoTextArea(Composite parent) {
// Status label
infoLabel = new Label(parent, SWT.RIGHT);
infoLabel.setText(infoText);
GridDataFactory.fillDefaults().grab(true, false).align(SWT.FILL, SWT.BEGINNING).applyTo(
infoLabel);
Display display = parent.getDisplay();
infoColor = new Color(display, blend(
display.getSystemColor(SWT.COLOR_INFO_BACKGROUND).getRGB(),
display.getSystemColor(SWT.COLOR_INFO_FOREGROUND).getRGB(),
0.56f));
infoLabel.setForeground(infoColor);
return infoLabel;
}
/**
* Creates the control to be used to represent the dialog's title text. Subclasses may override if
* a different control is desired for representing the title text, or if something different than
* the title should be displayed in location where the title text typically is shown.
* <p>
* If this method is overridden, the returned control's layout data must be an instance of
* <code>GridData</code>. This method must not modify the parent's layout.
*
* @param parent The parent composite.
* @return The Control representing the title area.
*/
protected Control createTitleControl(Composite parent) {
titleLabel = new Label(parent, SWT.NONE);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).span(
showDialogMenu ? 1 : 2,
1).applyTo(titleLabel);
if (titleText != null) {
titleLabel.setText(titleText);
}
return titleLabel;
}
/**
* Creates the title and menu area. Subclasses typically need not override this method, but
* instead should use the constructor parameters <code>showDialogMenu</code> and
* <code>showPersistAction</code> to indicate whether a menu should be shown, and
* <code>createTitleControl</code> to to customize the presentation of the title.
* <p>
* If this method is overridden, the returned control's layout data must be an instance of
* <code>GridData</code>. This method must not modify the parent's layout.
*
* @param parent The parent composite.
* @return The Control representing the title and menu area.
*/
protected Control createTitleMenuArea(Composite parent) {
Composite titleAreaComposite = new Composite(parent, SWT.NONE);
getPopupLayout().copy().numColumns(2).applyTo(titleAreaComposite);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).applyTo(
titleAreaComposite);
createTitleControl(titleAreaComposite);
if (showDialogMenu) {
createDialogMenu(titleAreaComposite);
}
return titleAreaComposite;
}
/**
* Fill the dialog's menu. Subclasses may extend or override.
*
* @param dialogMenu The dialog's menu.
*/
protected void fillDialogMenu(IMenuManager dialogMenu) {
dialogMenu.add(new GroupMarker("SystemMenuStart")); //$NON-NLS-1$
dialogMenu.add(new MoveAction());
dialogMenu.add(new ResizeAction());
if (showPersistActions) {
if (isUsing34API) {
dialogMenu.add(new PersistLocationAction());
dialogMenu.add(new PersistSizeAction());
} else {
dialogMenu.add(new PersistBoundsAction());
}
}
dialogMenu.add(new Separator("SystemMenuEnd")); //$NON-NLS-1$
}
/**
* Get the background color that should be used for this popup. Subclasses may override.
*
* @return the background color to be used. Should not be <code>null</code>.
* @since 3.4
* @see #getBackgroundColorExclusions()
*/
protected Color getBackground() {
return getDefaultBackground();
}
/**
* Return a list of controls which should never have their background color reset. Subclasses may
* extend this method, but should always call <code>super.getBackgroundColorExclusions</code> to
* aggregate the list.
*
* @return the List of controls
*/
protected List<Control> getBackgroundColorExclusions() {
List<Control> list = new ArrayList<Control>(2);
if (titleSeparator != null) {
list.add(titleSeparator);
}
if (infoSeparator != null) {
list.add(infoSeparator);
}
return list;
}
/**
* Returns the default location to use for the shell. This default location is used if the dialog
* does not have any persisted location to restore. The default implementation uses the location
* computed by {@link org.eclipse.jface.window.Window#getInitialLocation(Point)}. Subclasses
* should override this method when an alternate default location is desired, rather than
* overriding {@link #getInitialLocation(Point)}.
*
* @param initialSize the initial size of the shell, as returned by <code>getInitialSize</code>.
* @return the initial location of the shell
* @see #getPersistLocation()
* @since 3.4
*/
protected Point getDefaultLocation(Point initialSize) {
return super.getInitialLocation(initialSize);
}
/**
* Return the default size to use for the shell. This default size is used if the dialog does not
* have any persisted size to restore. The default implementation returns the preferred size of
* the shell. Subclasses should override this method when an alternate default size is desired,
* rather than overriding {@link #getInitialSize()}.
*
* @return the initial size of the shell
* @see #getPersistSize()
* @since 3.4
*/
protected Point getDefaultSize() {
return super.getInitialSize();
}
/**
* Gets the dialog settings that should be used for remembering the bounds of the dialog.
* Subclasses should override this method when they wish to persist the bounds of the dialog.
*
* @return settings the dialog settings used to store the dialog's location and/or size, or
* <code>null</code> if the dialog's bounds should never be stored.
*/
protected IDialogSettings getDialogSettings() {
return null;
}
/**
* Returns the control that should get initial focus. Subclasses may override this method.
*
* @return the Control that should receive focus when the popup opens.
*/
protected Control getFocusControl() {
return dialogArea;
}
/**
* Get the foreground color that should be used for this popup. Subclasses may override.
*
* @return the foreground color to be used. Should not be <code>null</code>.
* @since 3.4
* @see #getForegroundColorExclusions()
*/
protected Color getForeground() {
return getDefaultForeground();
}
/**
* Return a list of controls which should never have their foreground color reset. Subclasses may
* extend this method, but should always call <code>super.getForegroundColorExclusions</code> to
* aggregate the list.
*
* @return the List of controls
*/
protected List<Control> getForegroundColorExclusions() {
List<Control> list = new ArrayList<Control>(3);
if (infoLabel != null) {
list.add(infoLabel);
}
if (titleSeparator != null) {
list.add(titleSeparator);
}
if (infoSeparator != null) {
list.add(infoSeparator);
}
return list;
}
/**
* (non-Javadoc)
*
* @see org.eclipse.jface.window.Window#getInitialLocation(org.eclipse.swt.graphics.Point)
*/
@Override
protected Point getInitialLocation(Point initialSize) {
Point result = getDefaultLocation(initialSize);
if (persistLocation) {
IDialogSettings settings = getDialogSettings();
if (settings != null) {
try {
int x = settings.getInt(getClass().getName() + DIALOG_ORIGIN_X);
int y = settings.getInt(getClass().getName() + DIALOG_ORIGIN_Y);
result = new Point(x, y);
// The coordinates were stored relative to the parent shell.
// Convert to display coordinates.
Shell parent = getParentShell();
if (parent != null) {
Point parentLocation = parent.getLocation();
result.x += parentLocation.x;
result.y += parentLocation.y;
}
} catch (NumberFormatException e) {
}
}
}
// No attempt is made to constrain the bounds. The default
// constraining behavior in Window will be used.
return result;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jface.window.Window#getInitialSize()
*/
@Override
protected Point getInitialSize() {
Point result = getDefaultSize();
if (persistSize) {
IDialogSettings settings = getDialogSettings();
if (settings != null) {
try {
int width = settings.getInt(getClass().getName() + DIALOG_WIDTH);
int height = settings.getInt(getClass().getName() + DIALOG_HEIGHT);
result = new Point(width, height);
} catch (NumberFormatException e) {
}
}
}
// No attempt is made to constrain the bounds. The default
// constraining behavior in Window will be used.
return result;
}
/**
* Return a boolean indicating whether this dialog will persist its bounds. This value is
* initially set in the dialog's constructor, but can be modified if the persist bounds action is
* shown on the menu and the user has changed its value. Subclasses may override this method.
*
* @return <code>true</code> if the dialog's bounds will be persisted, <code>false</code> if it
* will not.
* @deprecated As of 3.4, please use {@link #getPersistLocation()} or {@link #getPersistSize()} to
* determine separately whether size or location should be persisted.
*/
@Deprecated
protected boolean getPersistBounds() {
return persistLocation && persistSize;
}
/**
* Return a boolean indicating whether this dialog will persist its location. This value is
* initially set in the dialog's constructor, but can be modified if the persist location action
* is shown on the menu and the user has changed its value. Subclasses may override this method.
*
* @return <code>true</code> if the dialog's location will be persisted, <code>false</code> if it
* will not.
* @see #getPersistSize()
* @since 3.4
*/
protected boolean getPersistLocation() {
return persistLocation;
}
/**
* Return a boolean indicating whether this dialog will persist its size. This value is initially
* set in the dialog's constructor, but can be modified if the persist size action is shown on the
* menu and the user has changed its value. Subclasses may override this method.
*
* @return <code>true</code> if the dialog's size will be persisted, <code>false</code> if it will
* not.
* @see #getPersistLocation()
* @since 3.4
*/
protected boolean getPersistSize() {
return persistSize;
}
/**
* Returns a boolean indicating whether the popup should have an info area at the bottom of the
* dialog. Subclasses may override. Default behavior is to have an info area if info text was
* provided at the time of creation.
*
* @return <code>true</code> if a title area should be created, <code>false</code> if it should
* not.
*/
protected boolean hasInfoArea() {
return infoText != null;
}
/**
* Returns a boolean indicating whether the popup should have a title area at the top of the
* dialog. Subclasses may override. Default behavior is to have a title area if there is to be a
* menu or title text.
*
* @return <code>true</code> if a title area should be created, <code>false</code> if it should
* not.
*/
protected boolean hasTitleArea() {
return titleText != null || showDialogMenu;
}
/**
* Saves the bounds of the shell in the appropriate dialog settings. The bounds are recorded
* relative to the parent shell, if there is one, or display coordinates if there is no parent
* shell. Subclasses typically need not override this method, but may extend it (calling
* <code>super.saveDialogBounds</code> if additional bounds information should be stored. Clients
* may also call this method to persist the bounds at times other than closing the dialog.
*
* @param shell The shell whose bounds are to be stored
*/
protected void saveDialogBounds(Shell shell) {
IDialogSettings settings = getDialogSettings();
if (settings != null) {
Point shellLocation = shell.getLocation();
Point shellSize = shell.getSize();
Shell parent = getParentShell();
if (parent != null) {
Point parentLocation = parent.getLocation();
shellLocation.x -= parentLocation.x;
shellLocation.y -= parentLocation.y;
}
String prefix = getClass().getName();
if (persistSize) {
settings.put(prefix + DIALOG_WIDTH, shellSize.x);
settings.put(prefix + DIALOG_HEIGHT, shellSize.y);
}
if (persistLocation) {
settings.put(prefix + DIALOG_ORIGIN_X, shellLocation.x);
settings.put(prefix + DIALOG_ORIGIN_Y, shellLocation.y);
}
if (showPersistActions && showDialogMenu) {
settings.put(getClass().getName() + DIALOG_USE_PERSISTED_SIZE, persistSize);
settings.put(getClass().getName() + DIALOG_USE_PERSISTED_LOCATION, persistLocation);
}
}
}
/**
* Set the text to be shown in the popup's info area. This message has no effect if there was no
* info text supplied when the dialog first opened. Subclasses may override this method.
*
* @param text the text to be shown when the info area is displayed.
*/
protected void setInfoText(String text) {
infoText = text;
if (infoLabel != null) {
infoLabel.setText(text);
}
}
/**
* Sets the tab order for the popup. Clients should override to introduce specific tab ordering.
*
* @param composite the composite in which all content, including the title area and info area,
* was created. This composite's parent is the shell.
*/
protected void setTabOrder(Composite composite) {
// default is to do nothing
}
/**
* Set the text to be shown in the popup's title area. This message has no effect if there was no
* title label specified when the dialog was originally opened. Subclasses may override this
* method.
*
* @param text the text to be shown when the title area is displayed.
*/
protected void setTitleText(String text) {
titleText = text;
if (titleLabel != null) {
titleLabel.setText(text);
}
}
/**
* Show the dialog's menu. This message has no effect if the receiver was not configured to show a
* menu. Clients may call this method in order to trigger the menu via keystrokes or other
* gestures. Subclasses typically do not override method.
*/
protected void showDialogMenu() {
if (!showDialogMenu) {
return;
}
if (menuManager == null) {
menuManager = new MenuManager();
fillDialogMenu(menuManager);
}
// Setting this flag works around a problem that remains on X only,
// whereby activating the menu deactivates our shell.
listenToDeactivate = !Util.isGtk();
Menu menu = menuManager.createContextMenu(getShell());
Rectangle bounds = toolBar.getBounds();
Point topLeft = new Point(bounds.x, bounds.y + bounds.height);
topLeft = getShell().toDisplay(topLeft);
menu.setLocation(topLeft.x, topLeft.y);
menu.setVisible(true);
}
/**
* Set the specified background color for the specified control and all of its children, except
* for those specified in the list of exclusions.
*
* @param color the color to use as the background color
* @param control the control whose color is to be changed
* @param exclusions a list of controls who are to be excluded from getting their color assigned
*/
private void applyBackgroundColor(Color color, Control control, List<Control> exclusions) {
if (!exclusions.contains(control)) {
control.setBackground(color);
}
if (control instanceof Composite) {
Control[] children = ((Composite) control).getChildren();
for (int i = 0; i < children.length; i++) {
applyBackgroundColor(color, children[i], exclusions);
}
}
}
/**
* Apply any desired color to the specified composite and its children.
*
* @param composite the contents composite
*/
private void applyColors(Composite composite) {
// The getForeground() and getBackground() methods
// should not answer null, but IColorProvider clients
// are accustomed to null meaning use the default, so we guard
// against this assumption.
Color color = getForeground();
if (color == null) {
color = getDefaultForeground();
}
applyForegroundColor(color, composite, getForegroundColorExclusions());
color = getBackground();
if (color == null) {
color = getDefaultBackground();
}
applyBackgroundColor(color, composite, getBackgroundColorExclusions());
}
/**
* Apply any desired fonts to the specified composite and its children.
*
* @param composite the contents composite
*/
private void applyFonts(Composite composite) {
Dialog.applyDialogFont(composite);
if (titleLabel != null) {
Font font = titleLabel.getFont();
FontData[] fontDatas = font.getFontData();
for (int i = 0; i < fontDatas.length; i++) {
fontDatas[i].setStyle(SWT.BOLD);
}
titleFont = SWTUtil.getFont(titleLabel.getDisplay(), fontDatas);
titleLabel.setFont(titleFont);
}
if (infoLabel != null) {
Font font = infoLabel.getFont();
FontData[] fontDatas = font.getFontData();
for (int i = 0; i < fontDatas.length; i++) {
fontDatas[i].setHeight(fontDatas[i].getHeight() * 9 / 10);
}
infoFont = SWTUtil.getFont(infoLabel.getDisplay(), fontDatas);
infoLabel.setFont(infoFont);
}
}
/**
* Set the specified foreground color for the specified control and all of its children, except
* for those specified in the list of exclusions.
*
* @param color the color to use as the foreground color
* @param control the control whose color is to be changed
* @param exclusions a list of controls who are to be excluded from getting their color assigned
*/
private void applyForegroundColor(Color color, Control control, List<Control> exclusions) {
if (!exclusions.contains(control)) {
control.setForeground(color);
}
if (control instanceof Composite) {
Control[] children = ((Composite) control).getChildren();
for (int i = 0; i < children.length; i++) {
applyForegroundColor(color, children[i], exclusions);
}
}
}
private void asyncClose() {
// workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=152010
getShell().getDisplay().asyncExec(new Runnable() {
@Override
public void run() {
close();
}
});
}
/**
* Create the dialog's menu for the move and resize actions.
*
* @param parent The parent composite.
*/
private void createDialogMenu(Composite parent) {
toolBar = new ToolBar(parent, SWT.FLAT);
ToolItem viewMenuButton = new ToolItem(toolBar, SWT.PUSH, 0);
GridDataFactory.fillDefaults().align(SWT.END, SWT.CENTER).applyTo(toolBar);
viewMenuButton.setImage(JFaceResources.getImage(POPUP_IMG_MENU));
viewMenuButton.setDisabledImage(JFaceResources.getImage(POPUP_IMG_MENU_DISABLED));
viewMenuButton.setToolTipText(JFaceResources.getString("BasePopupDialog.menuTooltip")); //$NON-NLS-1$
viewMenuButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent e) {
showDialogMenu();
}
});
// See https://bugs.eclipse.org/bugs/show_bug.cgi?id=177183
toolBar.addMouseListener(new MouseAdapter() {
@Override
public void mouseDown(MouseEvent e) {
showDialogMenu();
}
});
}
/**
* Create a horizontal separator for the given parent.
*
* @param parent The parent composite.
* @return The Control representing the horizontal separator.
*/
private Control createHorizontalSeparator(Composite parent) {
Label separator = new Label(parent, SWT.SEPARATOR | SWT.HORIZONTAL | SWT.LINE_DOT);
GridDataFactory.fillDefaults().align(SWT.FILL, SWT.CENTER).grab(true, false).applyTo(separator);
return separator;
}
/**
* Return the default background color used for popup dialogs.
*
* @return the default background color
*/
private Color getDefaultBackground() {
return getShell().getDisplay().getSystemColor(SWT.COLOR_INFO_BACKGROUND);
}
/**
* Return the default foreground color used for popup dialogs.
*
* @return the default foreground color.
*/
private Color getDefaultForeground() {
return getShell().getDisplay().getSystemColor(SWT.COLOR_INFO_FOREGROUND);
}
/**
* The dialog is being disposed. Dispose of any resources allocated.
*/
private void handleDispose() {
if (infoColor != null && !infoColor.isDisposed()) {
infoColor.dispose();
}
infoColor = null;
//TODO (pquitslund): stop doing this
// if (infoFont != null && !infoFont.isDisposed()) {
// infoFont.dispose();
// }
// infoFont = null;
if (titleFont != null && !titleFont.isDisposed()) {
titleFont.dispose();
}
titleFont = null;
}
/**
* Initialize any state related to the widgetry that should be set up each time widgets are
* created.
*/
private void initializeWidgetState() {
menuManager = null;
dialogArea = null;
titleLabel = null;
titleSeparator = null;
infoSeparator = null;
infoLabel = null;
toolBar = null;
// If the menu item for persisting bounds is displayed, use the stored
// value to determine whether any persisted bounds should be honored at
// all.
if (showDialogMenu && showPersistActions) {
IDialogSettings settings = getDialogSettings();
if (settings != null) {
String key = getClass().getName() + DIALOG_USE_PERSISTED_SIZE;
if (settings.get(key) != null || !isUsing34API) {
persistSize = settings.getBoolean(key);
}
key = getClass().getName() + DIALOG_USE_PERSISTED_LOCATION;
if (settings.get(key) != null || !isUsing34API) {
persistLocation = settings.getBoolean(key);
}
}
}
}
private void migrateBoundsSetting() {
IDialogSettings settings = getDialogSettings();
if (settings == null) {
return;
}
final String className = getClass().getName();
String key = className + DIALOG_USE_PERSISTED_BOUNDS;
String value = settings.get(key);
if (value == null || DIALOG_VALUE_MIGRATED_TO_34.equals(value)) {
return;
}
boolean storeBounds = settings.getBoolean(key);
settings.put(className + DIALOG_USE_PERSISTED_LOCATION, storeBounds);
settings.put(className + DIALOG_USE_PERSISTED_SIZE, storeBounds);
settings.put(key, DIALOG_VALUE_MIGRATED_TO_34);
}
/**
* Perform the requested tracker action (resize or move).
*
* @param style The track style (resize or move).
*/
private void performTrackerAction(int style) {
Shell shell = getShell();
if (shell == null || shell.isDisposed()) {
return;
}
Tracker tracker = new Tracker(shell.getDisplay(), style);
tracker.setStippled(true);
Rectangle[] r = new Rectangle[] {shell.getBounds()};
tracker.setRectangles(r);
// Ignore any deactivate events caused by opening the tracker.
// See https://bugs.eclipse.org/bugs/show_bug.cgi?id=120656
boolean oldListenToDeactivate = listenToDeactivate;
listenToDeactivate = false;
if (tracker.open()) {
if (!shell.isDisposed()) {
shell.setBounds(tracker.getRectangles()[0]);
}
}
tracker.dispose();
listenToDeactivate = oldListenToDeactivate;
}
}