Java tutorial
/******************************************************************************* * Copyright (c) 2009, 2012 SpringSource, a divison of VMware, Inc. * 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: * SpringSource, a division of VMware, Inc. - initial API and implementation *******************************************************************************/ package org.eclipse.virgo.ide.ui.editors.text; import org.eclipse.core.runtime.Assert; import org.eclipse.core.runtime.ListenerList; import org.eclipse.jface.action.ToolBarManager; import org.eclipse.jface.resource.JFaceResources; import org.eclipse.jface.text.IInformationControl; import org.eclipse.jface.text.IInformationControlCreator; import org.eclipse.jface.text.IInformationControlExtension; import org.eclipse.jface.text.IInformationControlExtension2; import org.eclipse.jface.text.IInformationControlExtension3; import org.eclipse.jface.text.IInformationControlExtension4; import org.eclipse.jface.util.Geometry; import org.eclipse.swt.SWT; import org.eclipse.swt.events.DisposeListener; import org.eclipse.swt.events.FocusEvent; import org.eclipse.swt.events.FocusListener; import org.eclipse.swt.events.MouseAdapter; import org.eclipse.swt.events.MouseEvent; import org.eclipse.swt.events.MouseMoveListener; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.graphics.Cursor; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.FontData; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.layout.GridData; import org.eclipse.swt.layout.GridLayout; import org.eclipse.swt.widgets.Canvas; 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.Shell; import org.eclipse.swt.widgets.Slider; import org.eclipse.swt.widgets.ToolBar; /** * An abstract information control that can show content inside a shell. The information control can be created in two * styles: * <ul> * <li>non-resizable tooltip with optional status</li> * <li>resizable tooltip with optional tool bar</li> * </ul> * Additionally it can present either a status line containing a status text or a toolbar containing toolbar buttons. * <p> * Subclasses must either override {@link IInformationControl#setInformation(String)} or implement * {@link IInformationControlExtension2}. They should also extend {@link #computeTrim()} if they create a content area * with additional trim (e.g. scrollbars) and override {@link #getInformationPresenterControlCreator()}. * </p> * * @author Christian Dupuis * @since 3.4 */ public abstract class JFaceAbstractInformationControl implements IInformationControl, IInformationControlExtension, IInformationControlExtension3, IInformationControlExtension4, JFaceIInformationControlExtension5 { /** The information control's shell. */ private final Shell fShell; /** Composite containing the content created by subclasses. */ private final Composite fContentComposite; /** Whether the information control is resizable. */ private final boolean fResizable; /** * Composite containing the status line content or <code>null</code> if none. */ private Composite fStatusComposite; /** Separator between content and status line or <code>null</code> if none. */ private Label fSeparator; /** Label in the status line or <code>null</code> if none. */ private Label fStatusLabel; /** The toolbar manager used by the toolbar or <code>null</code> if none. */ private final ToolBarManager fToolBarManager; /** Status line toolbar or <code>null</code> if none. */ private ToolBar fToolBar; /** Listener for shell activation and deactivation. */ private Listener fShellListener; /** All focus listeners registered to this information control. */ private final ListenerList fFocusListeners = new ListenerList(ListenerList.IDENTITY); /** * Size constraints, x is the maxWidth and y is the maxHeight, or <code>null</code> if not set. */ private Point fSizeConstraints; /** The size of the resize handle if already set, -1 otherwise */ private int fResizeHandleSize; /** * Creates an abstract information control with the given shell as parent. The control will not be resizable and * optionally show a status line with the given status field text. * <p> * <em>Important: Subclasses are required to call {@link #create()} at the end of their constructor.</em> * </p> * * @param parentShell the parent of this control's shell * @param statusFieldText the text to be used in the status field or <code>null</code> to hide the status field */ public JFaceAbstractInformationControl(Shell parentShell, String statusFieldText) { this(parentShell, SWT.TOOL | SWT.ON_TOP, statusFieldText, null); } /** * Creates an abstract information control with the given shell as parent. The control will be resizable and * optionally show a tool bar managed by the given tool bar manager. * <p> * <em>Important: Subclasses are required to call {@link #create()} at the end of their constructor.</em> * </p> * * @param parentShell the parent of this control's shell * @param toolBarManager the manager or <code>null</code> if toolbar is not desired */ public JFaceAbstractInformationControl(Shell parentShell, ToolBarManager toolBarManager) { this(parentShell, SWT.TOOL | SWT.ON_TOP | SWT.RESIZE, null, toolBarManager); } /** * Creates an abstract information control with the given shell as parent. * <p> * <em>Important: Subclasses are required to call {@link #create()} at the end of their constructor.</em> * </p> * * @param parentShell the parent of this control's shell * @param isResizable <code>true</code> if the control should be resizable */ public JFaceAbstractInformationControl(Shell parentShell, boolean isResizable) { this(parentShell, SWT.TOOL | SWT.ON_TOP | (isResizable ? SWT.RESIZE : 0), null, null); } /** * Creates an abstract information control with the given shell as parent. The given shell style is used for the * shell (NO_TRIM will be removed to make sure there's a border). * <p> * The control will optionally show either a status line or a tool bar. At most one of <code>toolBarManager</code> * or <code>statusFieldText</code> can be non-null. * </p> * <p> * <strong>Important:</strong>: Subclasses are required to call {@link #create()} at the end of their constructor. * </p> * * @param parentShell the parent of this control's shell * @param shellStyle style of this control's shell * @param statusFieldText the text to be used in the status field or <code>null</code> to hide the status field * @param toolBarManager the manager or <code>null</code> if toolbar is not desired * @deprecated clients should use one of the public constructors */ @Deprecated JFaceAbstractInformationControl(Shell parentShell, int shellStyle, final String statusFieldText, final ToolBarManager toolBarManager) { Assert.isTrue(statusFieldText == null || toolBarManager == null); this.fResizeHandleSize = -1; this.fToolBarManager = toolBarManager; if ((shellStyle & SWT.NO_TRIM) != 0) { shellStyle &= ~(SWT.NO_TRIM | SWT.SHELL_TRIM); // make sure we get // the OS border but // no other trims } this.fResizable = (shellStyle & SWT.RESIZE) != 0; // on GTK, Shell removes // SWT.RESIZE if SWT.ON_TOP // is set this.fShell = new Shell(parentShell, shellStyle); Display display = this.fShell.getDisplay(); Color foreground = display.getSystemColor(SWT.COLOR_INFO_FOREGROUND); Color background = display.getSystemColor(SWT.COLOR_INFO_BACKGROUND); setColor(this.fShell, foreground, background); GridLayout layout = new GridLayout(1, false); layout.marginHeight = 0; layout.marginWidth = 0; layout.verticalSpacing = 0; this.fShell.setLayout(layout); this.fContentComposite = new Composite(this.fShell, SWT.NONE); this.fContentComposite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true)); this.fContentComposite.setLayout(new FillLayout()); setColor(this.fContentComposite, foreground, background); createStatusComposite(statusFieldText, toolBarManager, foreground, background); } private void createStatusComposite(final String statusFieldText, final ToolBarManager toolBarManager, Color foreground, Color background) { if (toolBarManager == null && statusFieldText == null) { return; } this.fStatusComposite = new Composite(this.fShell, SWT.NONE); GridData gridData = new GridData(SWT.FILL, SWT.BOTTOM, true, false); this.fStatusComposite.setLayoutData(gridData); GridLayout statusLayout = new GridLayout(1, false); statusLayout.marginHeight = 0; statusLayout.marginWidth = 0; statusLayout.verticalSpacing = 1; this.fStatusComposite.setLayout(statusLayout); this.fSeparator = new Label(this.fStatusComposite, SWT.SEPARATOR | SWT.HORIZONTAL); this.fSeparator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); if (statusFieldText != null) { createStatusLabel(statusFieldText, foreground, background); } else { createToolBar(toolBarManager); } } private void createStatusLabel(final String statusFieldText, Color foreground, Color background) { this.fStatusLabel = new Label(this.fStatusComposite, SWT.RIGHT); this.fStatusLabel.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false)); this.fStatusLabel.setText(statusFieldText); FontData[] fontDatas = JFaceResources.getDialogFont().getFontData(); for (FontData element : fontDatas) { element.setHeight(element.getHeight() * 9 / 10); } this.fStatusLabel.setFont(new Font(this.fStatusLabel.getDisplay(), fontDatas)); this.fStatusLabel .setForeground(this.fStatusLabel.getDisplay().getSystemColor(SWT.COLOR_WIDGET_DARK_SHADOW)); this.fStatusLabel.setBackground(background); setColor(this.fStatusComposite, foreground, background); } private void createToolBar(ToolBarManager toolBarManager) { final Composite bars = new Composite(this.fStatusComposite, SWT.NONE); bars.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false)); GridLayout layout = new GridLayout(3, false); layout.marginHeight = 0; layout.marginWidth = 0; layout.horizontalSpacing = 0; layout.verticalSpacing = 0; bars.setLayout(layout); this.fToolBar = toolBarManager.createControl(bars); GridData gd = new GridData(SWT.BEGINNING, SWT.BEGINNING, false, false); this.fToolBar.setLayoutData(gd); Composite spacer = new Composite(bars, SWT.NONE); gd = new GridData(SWT.FILL, SWT.FILL, true, true); gd.widthHint = 0; gd.heightHint = 0; spacer.setLayoutData(gd); addMoveSupport(spacer); addResizeSupportIfNecessary(bars); } private void addResizeSupportIfNecessary(final Composite bars) { // XXX: workarounds for // - https://bugs.eclipse.org/bugs/show_bug.cgi?id=219139 : API to add // resize grip / grow box in lower right corner of shell // - https://bugs.eclipse.org/bugs/show_bug.cgi?id=23980 : platform // specific shell resize behavior String platform = SWT.getPlatform(); final boolean isWin = platform.equals("win32"); //$NON-NLS-1$ if (!isWin && !platform.equals("gtk")) { return; } final Canvas resizer = new Canvas(bars, SWT.NONE); int size = getResizeHandleSize(bars); GridData data = new GridData(SWT.END, SWT.END, false, true); data.widthHint = size; data.heightHint = size; resizer.setLayoutData(data); resizer.addPaintListener(new PaintListener() { public void paintControl(PaintEvent e) { Point s = resizer.getSize(); int x = s.x - 2; int y = s.y - 2; int min = Math.min(x, y); if (isWin) { // draw dots e.gc.setBackground(resizer.getDisplay().getSystemColor(SWT.COLOR_WIDGET_HIGHLIGHT_SHADOW)); int end = min - 1; for (int i = 0; i <= 2; i++) { for (int j = 0; j <= 2 - i; j++) { e.gc.fillRectangle(end - 4 * i, end - 4 * j, 2, 2); } } end--; e.gc.setBackground(resizer.getDisplay().getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW)); for (int i = 0; i <= 2; i++) { for (int j = 0; j <= 2 - i; j++) { e.gc.fillRectangle(end - 4 * i, end - 4 * j, 2, 2); } } } else { // draw diagonal lines e.gc.setForeground(resizer.getDisplay().getSystemColor(SWT.COLOR_WIDGET_NORMAL_SHADOW)); for (int i = 1; i < min; i += 4) { e.gc.drawLine(i, y, x, i); } e.gc.setForeground(resizer.getDisplay().getSystemColor(SWT.COLOR_WIDGET_HIGHLIGHT_SHADOW)); for (int i = 2; i < min; i += 4) { e.gc.drawLine(i, y, x, i); } } } }); resizer.setCursor(new Cursor(resizer.getDisplay(), SWT.CURSOR_SIZESE)); MouseAdapter resizeSupport = new MouseAdapter() { private MouseMoveListener fResizeListener; @Override public void mouseDown(MouseEvent e) { Point shellSize = JFaceAbstractInformationControl.this.fShell.getSize(); final int shellX = shellSize.x; final int shellY = shellSize.y; Point mouseLoc = resizer.toDisplay(e.x, e.y); final int mouseX = mouseLoc.x; final int mouseY = mouseLoc.y; this.fResizeListener = new MouseMoveListener() { public void mouseMove(MouseEvent e2) { Point mouseLoc2 = resizer.toDisplay(e2.x, e2.y); int dx = mouseLoc2.x - mouseX; int dy = mouseLoc2.y - mouseY; setSize(shellX + dx, shellY + dy); } }; resizer.addMouseMoveListener(this.fResizeListener); } @Override public void mouseUp(MouseEvent e) { resizer.removeMouseMoveListener(this.fResizeListener); this.fResizeListener = null; } }; resizer.addMouseListener(resizeSupport); } private int getResizeHandleSize(Composite parent) { if (this.fResizeHandleSize == -1) { Slider sliderV = new Slider(parent, SWT.VERTICAL); Slider sliderH = new Slider(parent, SWT.HORIZONTAL); int width = sliderV.computeSize(SWT.DEFAULT, SWT.DEFAULT).x; int height = sliderH.computeSize(SWT.DEFAULT, SWT.DEFAULT).y; sliderV.dispose(); sliderH.dispose(); this.fResizeHandleSize = Math.min(width, height); } return this.fResizeHandleSize; } /** * Adds support to move the shell by dragging the given control. * * @param control the control that can be used to move the shell */ private void addMoveSupport(final Control control) { MouseAdapter moveSupport = new MouseAdapter() { private MouseMoveListener fMoveListener; @Override public void mouseDown(MouseEvent e) { Point shellLoc = JFaceAbstractInformationControl.this.fShell.getLocation(); final int shellX = shellLoc.x; final int shellY = shellLoc.y; Point mouseLoc = control.toDisplay(e.x, e.y); final int mouseX = mouseLoc.x; final int mouseY = mouseLoc.y; this.fMoveListener = new MouseMoveListener() { public void mouseMove(MouseEvent e2) { Point mouseLoc2 = control.toDisplay(e2.x, e2.y); int dx = mouseLoc2.x - mouseX; int dy = mouseLoc2.y - mouseY; JFaceAbstractInformationControl.this.fShell.setLocation(shellX + dx, shellY + dy); } }; control.addMouseMoveListener(this.fMoveListener); } @Override public void mouseUp(MouseEvent e) { control.removeMouseMoveListener(this.fMoveListener); this.fMoveListener = null; } }; control.addMouseListener(moveSupport); } /** * Utility to set the foreground and the background color of the given control * * @param control the control to modify * @param foreground the color to use for the foreground * @param background the color to use for the background */ private static void setColor(Control control, Color foreground, Color background) { control.setForeground(foreground); control.setBackground(background); } /** * The shell of the popup window. * * @return the shell used for the popup window */ protected final Shell getShell() { return this.fShell; } /** * The toolbar manager used to manage the toolbar, or <code>null</code> if no toolbar is shown. * * @return the tool bar manager or <code>null</code> */ protected final ToolBarManager getToolBarManager() { return this.fToolBarManager; } /** * Creates the content of this information control. Subclasses must call this method at the end of their * constructor(s). */ protected final void create() { createContent(this.fContentComposite); } /** * Creates the content of the popup window. * <p> * Implementors will usually take over {@link Composite#getBackground()} and {@link Composite#getForeground()} from * <code>parent</code>. * </p> * <p> * Implementors are expected to consider {@link #isResizable()}: If <code>true</code>, they should show scrollbars * if their content may exceed the size of the information control. If <code>false</code>, they should never show * scrollbars. * </p> * <p> * The given <code>parent</code> comes with a {@link FillLayout}. Subclasses may set a different layout. * </p> * * @param parent the container of the content */ protected abstract void createContent(Composite parent); /** * Sets the information to be presented by this information control. * <p> * The default implementation does nothing. Subclasses must either override this method or implement * {@link IInformationControlExtension2}. * * @param information the information to be presented * @see org.eclipse.jface.text.IInformationControl#setInformation(java.lang.String) */ public void setInformation(String information) { } /** * Returns whether the information control is resizable. * * @return <code>true</code> if the information control is resizable, <code>false</code> if it is not resizable. */ public boolean isResizable() { return this.fResizable; } /* * @see IInformationControl#setVisible(boolean) */ public void setVisible(boolean visible) { if (this.fShell.isVisible() == visible) { return; } this.fShell.setVisible(visible); } /* * @see IInformationControl#dispose() */ public void dispose() { if (this.fShell != null && !this.fShell.isDisposed()) { this.fShell.dispose(); } } /* * @see IInformationControl#setSize(int, int) */ public void setSize(int width, int height) { this.fShell.setSize(width, height); } /* * @see IInformationControl#setLocation(Point) */ public void setLocation(Point location) { this.fShell.setLocation(location); } /* * @see IInformationControl#setSizeConstraints(int, int) */ public void setSizeConstraints(int maxWidth, int maxHeight) { this.fSizeConstraints = new Point(maxWidth, maxHeight); } /** * Returns the size constraints. * * @return the size constraints or <code>null</code> if not set * @see #setSizeConstraints(int, int) */ protected final Point getSizeConstraints() { return this.fSizeConstraints != null ? Geometry.copy(this.fSizeConstraints) : null; } /* * @see IInformationControl#computeSizeHint() */ public Point computeSizeHint() { // XXX: Verify whether this is a good default implementation. If yes, // document it. Point constrains = getSizeConstraints(); if (constrains == null) { return this.fShell.computeSize(SWT.DEFAULT, SWT.DEFAULT, true); } return this.fShell.computeSize(constrains.x, constrains.y, true); } /** * Computes the trim (status text and tool bar are considered as trim). Subclasses can extend this method to add * additional trim (e.g. scroll bars for resizable information controls). * * @see org.eclipse.jface.text.IInformationControlExtension3#computeTrim() */ public Rectangle computeTrim() { Rectangle trim = this.fShell.computeTrim(0, 0, 0, 0); if (this.fStatusComposite != null) { trim.height += this.fStatusComposite.computeSize(SWT.DEFAULT, SWT.DEFAULT).y; } return trim; } /* * @see org.eclipse.jface.text.IInformationControlExtension3#getBounds() */ public Rectangle getBounds() { return this.fShell.getBounds(); } /** * {@inheritDoc} * <p> * The default implementation always returns <code>false</code>. * </p> * * @see org.eclipse.jface.text.IInformationControlExtension3#restoresLocation() */ public boolean restoresLocation() { return false; } /** * {@inheritDoc} * <p> * The default implementation always returns <code>false</code>. * </p> * * @see org.eclipse.jface.text.IInformationControlExtension3#restoresSize() */ public boolean restoresSize() { return false; } /* * @see IInformationControl#addDisposeListener(DisposeListener) */ public void addDisposeListener(DisposeListener listener) { this.fShell.addDisposeListener(listener); } /* * @see IInformationControl#removeDisposeListener(DisposeListener) */ public void removeDisposeListener(DisposeListener listener) { this.fShell.removeDisposeListener(listener); } /* * @see IInformationControl#setForegroundColor(Color) */ public void setForegroundColor(Color foreground) { this.fContentComposite.setForeground(foreground); } /* * @see IInformationControl#setBackgroundColor(Color) */ public void setBackgroundColor(Color background) { this.fContentComposite.setBackground(background); } /** * {@inheritDoc} This method is not intended to be overridden by subclasses. */ public boolean isFocusControl() { return this.fShell.getDisplay().getActiveShell() == this.fShell; } /** * This default implementation sets the focus on the popup shell. Subclasses can override or extend. * * @see IInformationControl#setFocus() */ public void setFocus() { boolean focusTaken = this.fShell.setFocus(); if (!focusTaken) { this.fShell.forceFocus(); } } /** * {@inheritDoc} This method is not intended to be overridden by subclasses. */ public void addFocusListener(final FocusListener listener) { if (this.fFocusListeners.isEmpty()) { this.fShellListener = new Listener() { public void handleEvent(Event event) { Object[] listeners = JFaceAbstractInformationControl.this.fFocusListeners.getListeners(); for (Object element : listeners) { FocusListener focusListener = (FocusListener) element; if (event.type == SWT.Activate) { focusListener.focusGained(new FocusEvent(event)); } else { focusListener.focusLost(new FocusEvent(event)); } } } }; this.fShell.addListener(SWT.Deactivate, this.fShellListener); this.fShell.addListener(SWT.Activate, this.fShellListener); } this.fFocusListeners.add(listener); } /** * {@inheritDoc} This method is not intended to be overridden by subclasses. */ public void removeFocusListener(FocusListener listener) { this.fFocusListeners.remove(listener); if (this.fFocusListeners.isEmpty()) { this.fShell.removeListener(SWT.Activate, this.fShellListener); this.fShell.removeListener(SWT.Deactivate, this.fShellListener); this.fShellListener = null; } } /** * Sets the text of the status field. * <p> * The default implementation currently only updates the status field when the popup shell is not visible. The * status field can currently only be shown if the information control has been created with a non-null status field * text. * </p> * * @param statusFieldText the text to be used in the optional status field or <code>null</code> if the status field * should be hidden * @see org.eclipse.jface.text.IInformationControlExtension4#setStatusText(java.lang.String) */ public void setStatusText(String statusFieldText) { if (this.fStatusLabel != null && !getShell().isVisible()) { if (statusFieldText == null) { this.fStatusComposite.setVisible(false); } else { this.fStatusLabel.setText(statusFieldText); this.fStatusComposite.setVisible(true); } } } /* * @see org.eclipse.jface.text.IInformationControlExtension5#containsControl( org.eclipse.swt.widgets.Control) */ public boolean containsControl(Control control) { do { if (control == this.fShell) { return true; } if (control instanceof Shell) { return false; } control = control.getParent(); } while (control != null); return false; } /* * @see org.eclipse.jface.text.IInformationControlExtension5#isVisible() */ public boolean isVisible() { return this.fShell != null && !this.fShell.isDisposed() && this.fShell.isVisible(); } /** * {@inheritDoc} This default implementation returns <code>null</code>. Subclasses may override. */ public IInformationControlCreator getInformationPresenterControlCreator() { return null; } /** * Computes the size constraints based on the {@link JFaceResources#getDialogFont() dialog font}. Subclasses can * override or extend. * * @see org.eclipse.jface.text.IInformationControlExtension5#computeSizeConstraints(int, int) */ public Point computeSizeConstraints(int widthInChars, int heightInChars) { GC gc = new GC(this.fContentComposite); gc.setFont(JFaceResources.getDialogFont()); int width = gc.getFontMetrics().getAverageCharWidth(); int height = gc.getFontMetrics().getHeight(); gc.dispose(); return new Point(widthInChars * width, heightInChars * height); } }