| /******************************************************************************* |
| * Copyright (c) 2000, 2010 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 |
| * Austin Riddle (Texas Center for Applied Technology) - initial RAP port |
| *******************************************************************************/ |
| package org.eclipse.draw2d; |
| |
| import java.beans.PropertyChangeEvent; |
| import java.beans.PropertyChangeListener; |
| |
| import org.eclipse.draw2d.geometry.Dimension; |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.draw2d.geometry.Rectangle; |
| import org.eclipse.rap.rwt.internal.textsize.TextSizeUtil; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.DragDetectListener; |
| import org.eclipse.swt.events.FocusListener; |
| import org.eclipse.swt.events.KeyListener; |
| import org.eclipse.swt.events.MenuDetectListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.widgets.Canvas; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Layout; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Menu; |
| import org.eclipse.swt.widgets.Slider; |
| |
| /** |
| * A scrolling Canvas that contains {@link Figure Figures} viewed through a |
| * {@link Viewport}. Call {@link #setContents(IFigure)} to specify the root of |
| * the tree of <tt>Figures</tt> to be viewed through the <tt>Viewport</tt>. |
| * <p> |
| * Normal procedure for using a FigureCanvas: |
| * <ol> |
| * <li>Create a FigureCanvas. |
| * <li>Create a Draw2d Figure and call {@link #setContents(IFigure)}. This |
| * Figure will be the top-level Figure of the Draw2d application. |
| * </ol> |
| * <dl> |
| * <dt><b>Required Styles (when using certain constructors):</b></dt> |
| * <dd>V_SCROLL, H_SCROLL, NO_REDRAW_RESIZE</dd> |
| * <dt><b>Optional Styles:</b></dt> |
| * <dd>DOUBLE_BUFFERED, RIGHT_TO_LEFT, LEFT_TO_RIGHT, NO_BACKGROUND, BORDER</dd> |
| * </dl> |
| * <p> |
| * Note: Only one of the styles RIGHT_TO_LEFT, LEFT_TO_RIGHT may be specified. |
| * </p> |
| */ |
| public class FigureCanvas extends Composite { |
| |
| private static final int ACCEPTED_STYLES = SWT.RIGHT_TO_LEFT |
| | SWT.LEFT_TO_RIGHT |
| | SWT.V_SCROLL |
| | SWT.H_SCROLL |
| | SWT.NO_BACKGROUND |
| | SWT.NO_REDRAW_RESIZE |
| | SWT.DOUBLE_BUFFERED |
| | SWT.BORDER; |
| |
| /** |
| * The default styles are mixed in when certain constructors are used. This |
| * constant is a bitwise OR of the following SWT style constants: |
| * <UL> |
| * <LI>{@link SWT#NO_REDRAW_RESIZE}</LI> |
| * <LI>{@link SWT#NO_BACKGROUND}</LI> |
| * <LI>{@link SWT#V_SCROLL}</LI> |
| * <LI>{@link SWT#H_SCROLL}</LI> |
| * </UL> |
| */ |
| static final int DEFAULT_STYLES = SWT.NO_REDRAW_RESIZE | SWT.NO_BACKGROUND |
| | SWT.V_SCROLL | SWT.H_SCROLL; |
| |
| private static final int REQUIRED_STYLES = SWT.NO_REDRAW_RESIZE |
| | SWT.V_SCROLL | SWT.H_SCROLL; |
| |
| /** Never show scrollbar */ |
| public static int NEVER = 0; |
| /** Automatically show scrollbar when needed */ |
| public static int AUTOMATIC = 1; |
| /** Always show scrollbar */ |
| public static int ALWAYS = 2; |
| |
| protected Slider horizontalBar, verticalBar; |
| protected Canvas innerCanvas; |
| |
| private int vBarVisibility = AUTOMATIC; |
| private int hBarVisibility = AUTOMATIC; |
| private Viewport viewport; |
| private Font font; |
| private int hBarOffset; |
| private int vBarOffset; |
| |
| private PropertyChangeListener horizontalChangeListener = new PropertyChangeListener() { |
| public void propertyChange(PropertyChangeEvent event) { |
| RangeModel model = getViewport().getHorizontalRangeModel(); |
| hBarOffset = Math.max(0, -model.getMinimum()); |
| Slider horizontalBar = getHorizontalSlider(); |
| if (horizontalBar != null) { |
| horizontalBar.setValues(model.getValue() + hBarOffset, |
| model.getMinimum() + hBarOffset, model.getMaximum() |
| + hBarOffset, model.getExtent(), |
| Math.max(1, model.getExtent() / 20), |
| Math.max(1, model.getExtent() * 3 / 4)); |
| } |
| } |
| }; |
| |
| private PropertyChangeListener verticalChangeListener = new PropertyChangeListener() { |
| public void propertyChange(PropertyChangeEvent event) { |
| RangeModel model = getViewport().getVerticalRangeModel(); |
| vBarOffset = Math.max(0, -model.getMinimum()); |
| Slider verticalBar = getVerticalSlider(); |
| if (verticalBar != null) { |
| verticalBar.setValues(model.getValue() + vBarOffset, |
| model.getMinimum() + vBarOffset, model.getMaximum() |
| + vBarOffset, model.getExtent(), |
| Math.max(1, model.getExtent() / 20), |
| Math.max(1, model.getExtent() * 3 / 4)); |
| } |
| } |
| }; |
| |
| private final LightweightSystem lws; |
| |
| /** |
| * Creates a new FigureCanvas with the given parent and the |
| * {@link #DEFAULT_STYLES}. |
| * |
| * @param parent |
| * the parent |
| */ |
| public FigureCanvas(Composite parent) { |
| this(parent, SWT.DOUBLE_BUFFERED, new LightweightSystem()); |
| } |
| |
| /** |
| * Constructor which applies the default styles plus any optional styles |
| * indicated. |
| * |
| * @param parent |
| * the parent composite |
| * @param style |
| * see the class javadoc for optional styles |
| * @since 3.1 |
| */ |
| public FigureCanvas(Composite parent, int style) { |
| this(parent, style, new LightweightSystem()); |
| } |
| |
| /** |
| * Constructor which uses the given styles verbatim. Certain styles must be |
| * used with this class. Refer to the class javadoc for more details. |
| * |
| * @param style |
| * see the class javadoc for <b>required</b> and optional styles |
| * @param parent |
| * the parent composite |
| * @since 3.4 |
| */ |
| public FigureCanvas(int style, Composite parent) { |
| this(style, parent, new LightweightSystem()); |
| } |
| |
| /** |
| * Constructs a new FigureCanvas with the given parent and |
| * LightweightSystem, using the {@link #DEFAULT_STYLES}. |
| * |
| * @param parent |
| * the parent |
| * @param lws |
| * the LightweightSystem |
| */ |
| public FigureCanvas(Composite parent, LightweightSystem lws) { |
| this(parent, SWT.DOUBLE_BUFFERED, lws); |
| } |
| |
| /** |
| * Constructor taking a lightweight system and SWT style, which is used |
| * verbatim. Certain styles must be used with this class. Refer to the class |
| * javadoc for more details. |
| * |
| * @param style |
| * see the class javadoc for <b>required</b> and optional styles |
| * @param parent |
| * the parent composite |
| * @param lws |
| * the LightweightSystem |
| * @since 3.4 |
| */ |
| public FigureCanvas(int style, Composite parent, LightweightSystem lws) { |
| super(parent, checkStyle(style)); |
| setLayout(new Layout() { |
| protected org.eclipse.swt.graphics.Point computeSize( |
| Composite composite, int wHint, int hHint, |
| boolean flushCache) { |
| return innerCanvas.computeSize(wHint, hHint, flushCache); |
| } |
| |
| protected void layout(Composite composite, boolean flushCache) { |
| //re layout only outside textsize determination event, to avoid |
| //unwanted scrolling top left with big diagram |
| if(!TextSizeUtil.isTemporaryResize()) { |
| org.eclipse.swt.graphics.Point size = composite.getSize(); |
| int vScrollBarWidth = getVScrollBarWidth(); |
| int hScrollBarHeight = getHScrollBarHeight(); |
| if (!getHorizontalSlider().isVisible()) { |
| hScrollBarHeight = 0; |
| } |
| if (!getVerticalSlider().isVisible()) { |
| vScrollBarWidth = 0; |
| } |
| getHorizontalSlider().setBounds(0, size.y - hScrollBarHeight, |
| size.x - vScrollBarWidth, hScrollBarHeight); |
| getVerticalSlider().setBounds(size.x - vScrollBarWidth, 0, |
| vScrollBarWidth, size.y - hScrollBarHeight); |
| innerCanvas.setLocation(0, 0); |
| innerCanvas.setSize(size.x - vScrollBarWidth, size.y |
| - hScrollBarHeight); |
| } |
| } |
| }); |
| Slider horizontalBar = getHorizontalSlider(); |
| if (horizontalBar != null) { |
| horizontalBar.setVisible(false); |
| } |
| Slider verticalBar = getVerticalSlider(); |
| if (verticalBar != null) { |
| verticalBar.setVisible(false); |
| } |
| this.lws = lws; |
| lws.setControl(getInnerCanvas()); |
| hook(); |
| } |
| |
| public org.eclipse.swt.graphics.Rectangle getClientArea() { |
| return innerCanvas.getClientArea(); |
| } |
| |
| private Canvas getInnerCanvas() { |
| if (innerCanvas == null) { |
| innerCanvas = new Canvas(this, getStyle()); |
| this.setData(Canvas.class.getName(), innerCanvas); |
| } |
| return innerCanvas; |
| } |
| |
| /** |
| * Constructor |
| * |
| * @param parent |
| * the parent composite |
| * @param style |
| * look at class javadoc for valid styles |
| * @param lws |
| * the lightweight system |
| * @since 3.1 |
| */ |
| public FigureCanvas(Composite parent, int style, LightweightSystem lws) { |
| this(style | DEFAULT_STYLES, parent, lws); |
| } |
| |
| private static int checkStyle(int style) { |
| if ((style & REQUIRED_STYLES) != REQUIRED_STYLES) |
| throw new IllegalArgumentException( |
| "Required style missing on FigureCanvas"); //$NON-NLS-1$ |
| if ((style & ~ACCEPTED_STYLES) != 0) |
| throw new IllegalArgumentException( |
| "Invalid style being set on FigureCanvas"); //$NON-NLS-1$ |
| return style; |
| } |
| |
| public void addFocusListener(FocusListener listener) { |
| super.addFocusListener(listener); |
| getInnerCanvas().addFocusListener(listener); |
| } |
| |
| public void addDragDetectListener(DragDetectListener listener) { |
| super.addDragDetectListener(listener); |
| getInnerCanvas().addDragDetectListener(listener); |
| } |
| |
| public void addMenuDetectListener(MenuDetectListener listener) { |
| super.addMenuDetectListener(listener); |
| getInnerCanvas().addMenuDetectListener(listener); |
| } |
| |
| public void addKeyListener(KeyListener listener) { |
| super.addKeyListener(listener); |
| getInnerCanvas().addKeyListener(listener); |
| } |
| |
| public void addListener(int eventType, Listener listener) { |
| super.addListener(eventType, listener); |
| getInnerCanvas().addListener(eventType, listener); |
| } |
| |
| public void removeFocusListener(FocusListener listener) { |
| super.removeFocusListener(listener); |
| getInnerCanvas().removeFocusListener(listener); |
| } |
| |
| public void removeDragDetectListener(DragDetectListener listener) { |
| super.removeDragDetectListener(listener); |
| getInnerCanvas().removeDragDetectListener(listener); |
| } |
| |
| public void removeMenuDetectListener(MenuDetectListener listener) { |
| super.removeMenuDetectListener(listener); |
| getInnerCanvas().removeMenuDetectListener(listener); |
| } |
| |
| public void removeKeyListener(KeyListener listener) { |
| super.removeKeyListener(listener); |
| getInnerCanvas().removeKeyListener(listener); |
| } |
| |
| public void removeListener(int eventType, Listener listener) { |
| super.removeListener(eventType, listener); |
| getInnerCanvas().removeListener(eventType, listener); |
| } |
| |
| /** |
| * @see org.eclipse.swt.widgets.Composite#computeSize(int, int, boolean) |
| */ |
| public org.eclipse.swt.graphics.Point computeSize(int wHint, int hHint, |
| boolean changed) { |
| // TODO Still doesn't handle scrollbar cases, such as when a constrained |
| // width |
| // would require a horizontal scrollbar, and therefore additional |
| // height. |
| int borderSize = computeTrim(0, 0, 0, 0).x * -2; |
| if (wHint >= 0) |
| wHint = Math.max(0, wHint - borderSize); |
| if (hHint >= 0) |
| hHint = Math.max(0, hHint - borderSize); |
| Dimension size = getLightweightSystem().getRootFigure() |
| .getPreferredSize(wHint, hHint) |
| .getExpanded(borderSize, borderSize); |
| size.union(new Dimension(wHint, hHint)); |
| return new org.eclipse.swt.graphics.Point(size.width, size.height); |
| } |
| |
| /** |
| * @return the contents of the {@link Viewport}. |
| */ |
| public IFigure getContents() { |
| return getViewport().getContents(); |
| } |
| |
| /** |
| * @see org.eclipse.swt.widgets.Control#getFont() |
| */ |
| public Font getFont() { |
| if (font == null) |
| font = super.getFont(); |
| return font; |
| } |
| |
| /** |
| * @return the horizontal scrollbar visibility. |
| */ |
| public int getHorizontalScrollBarVisibility() { |
| return hBarVisibility; |
| } |
| |
| int getVScrollBarWidth() { |
| return 16; |
| } |
| |
| int getHScrollBarHeight() { |
| return 16; |
| } |
| |
| /** |
| * @return the LightweightSystem |
| */ |
| public LightweightSystem getLightweightSystem() { |
| return lws; |
| } |
| |
| /** |
| * @return the vertical scrollbar visibility. |
| */ |
| public int getVerticalScrollBarVisibility() { |
| return vBarVisibility; |
| } |
| |
| /** |
| * Returns the Viewport. If it's <code>null</code>, a new one is created. |
| * |
| * @return the viewport |
| */ |
| public Viewport getViewport() { |
| if (viewport == null) |
| setViewport(new Viewport(true)); |
| return viewport; |
| } |
| |
| /** |
| * Adds listeners for scrolling. |
| */ |
| private void hook() { |
| getLightweightSystem().getUpdateManager().addUpdateListener( |
| new UpdateListener() { |
| public void notifyPainting(Rectangle damage, |
| java.util.Map dirtyRegions) { |
| } |
| |
| public void notifyValidating() { |
| if (!isDisposed()) |
| layoutViewport(); |
| } |
| }); |
| |
| final Slider horizontalBar = getHorizontalSlider(); |
| if (horizontalBar != null) { |
| horizontalBar.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent event) { |
| scrollToX(horizontalBar.getSelection() - hBarOffset); |
| } |
| }); |
| } |
| |
| final Slider verticalBar = getVerticalSlider(); |
| if (verticalBar != null) { |
| verticalBar.addSelectionListener(new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent event) { |
| scrollToY(verticalBar.getSelection() - vBarOffset); |
| } |
| }); |
| } |
| } |
| |
| private void hookViewport() { |
| getViewport().getHorizontalRangeModel().addPropertyChangeListener( |
| horizontalChangeListener); |
| getViewport().getVerticalRangeModel().addPropertyChangeListener( |
| verticalChangeListener); |
| } |
| |
| private void unhookViewport() { |
| getViewport().getHorizontalRangeModel().removePropertyChangeListener( |
| horizontalChangeListener); |
| getViewport().getVerticalRangeModel().removePropertyChangeListener( |
| verticalChangeListener); |
| } |
| |
| private void layoutViewport() { |
| ScrollPaneSolver.Result result; |
| result = ScrollPaneSolver.solve( |
| new Rectangle(innerCanvas.getBounds()).setLocation(0, 0), |
| getViewport(), getHorizontalScrollBarVisibility(), |
| getVerticalScrollBarVisibility(), |
| innerCanvas.computeTrim(0, 0, 0, 0).width, |
| innerCanvas.computeTrim(0, 0, 0, 0).height); |
| getLightweightSystem().setIgnoreResize(true); |
| try { |
| Slider horizontalBar = getHorizontalSlider(); |
| if (horizontalBar != null |
| && horizontalBar.getVisible() != result.showH) { |
| horizontalBar.setVisible(result.showH); |
| layout(new Control[] { horizontalBar }); |
| } |
| Slider verticalBar = getVerticalSlider(); |
| if (verticalBar != null && verticalBar.getVisible() != result.showV) { |
| verticalBar.setVisible(result.showV); |
| layout(new Control[] { verticalBar }); |
| } |
| Rectangle r = new Rectangle(getClientArea()); |
| r.setLocation(0, 0); |
| getLightweightSystem().getRootFigure().setBounds(r); |
| } finally { |
| getLightweightSystem().setIgnoreResize(false); |
| } |
| } |
| |
| /** |
| * Scrolls in an animated way to the new x and y location. |
| * |
| * @param x |
| * the x coordinate to scroll to |
| * @param y |
| * the y coordinate to scroll to |
| */ |
| public void scrollSmoothTo(int x, int y) { |
| // Ensure newHOffset and newVOffset are within the appropriate ranges |
| x = verifyScrollBarOffset(getViewport().getHorizontalRangeModel(), x); |
| y = verifyScrollBarOffset(getViewport().getVerticalRangeModel(), y); |
| |
| int oldX = getViewport().getViewLocation().x; |
| int oldY = getViewport().getViewLocation().y; |
| int dx = x - oldX; |
| int dy = y - oldY; |
| |
| if (dx == 0 && dy == 0) |
| return; // Nothing to do. |
| |
| Dimension viewingArea = getViewport().getClientArea().getSize(); |
| |
| int minFrames = 3; |
| int maxFrames = 6; |
| if (dx == 0 || dy == 0) { |
| minFrames = 6; |
| maxFrames = 13; |
| } |
| int frames = (Math.abs(dx) + Math.abs(dy)) / 15; |
| frames = Math.max(frames, minFrames); |
| frames = Math.min(frames, maxFrames); |
| |
| int stepX = Math.min((dx / frames), (viewingArea.width / 3)); |
| int stepY = Math.min((dy / frames), (viewingArea.height / 3)); |
| |
| for (int i = 1; i < frames; i++) { |
| scrollTo(oldX + i * stepX, oldY + i * stepY); |
| getViewport().getUpdateManager().performUpdate(); |
| } |
| scrollTo(x, y); |
| } |
| |
| /** |
| * Scrolls the contents to the new x and y location. If this scroll |
| * operation only consists of a vertical or horizontal scroll, a call will |
| * be made to {@link #scrollToY(int)} or {@link #scrollToX(int)}, |
| * respectively, to increase performance. |
| * |
| * @param x |
| * the x coordinate to scroll to |
| * @param y |
| * the y coordinate to scroll to |
| */ |
| public void scrollTo(int x, int y) { |
| x = verifyScrollBarOffset(getViewport().getHorizontalRangeModel(), x); |
| y = verifyScrollBarOffset(getViewport().getVerticalRangeModel(), y); |
| if (x == getViewport().getViewLocation().x) |
| scrollToY(y); |
| else if (y == getViewport().getViewLocation().y) |
| scrollToX(x); |
| else |
| getViewport().setViewLocation(x, y); |
| } |
| |
| /** |
| * Scrolls the contents horizontally so that they are offset by |
| * <code>hOffset</code>. |
| * |
| * @param hOffset |
| * the new horizontal offset |
| */ |
| public void scrollToX(int hOffset) { |
| hOffset = verifyScrollBarOffset( |
| getViewport().getHorizontalRangeModel(), hOffset); |
| int hOffsetOld = getViewport().getViewLocation().x; |
| if (hOffset == hOffsetOld) |
| return; |
| int dx = -hOffset + hOffsetOld; |
| |
| Rectangle clientArea = getViewport().getBounds().getCropped( |
| getViewport().getInsets()); |
| Rectangle blit = clientArea.getResized(-Math.abs(dx), 0); |
| Rectangle expose = clientArea.getCopy(); |
| Point dest = clientArea.getTopLeft(); |
| expose.width = Math.abs(dx); |
| if (dx < 0) { // Moving left? |
| blit.translate(-dx, 0); // Move blit area to the right |
| expose.x = dest.x + blit.width; |
| } else |
| // Moving right |
| dest.x += dx; // Move expose area to the right |
| |
| // fix for bug 41111 |
| Control[] children = getInnerCanvas().getChildren(); |
| boolean[] manualMove = new boolean[children.length]; |
| for (int i = 0; i < children.length; i++) { |
| org.eclipse.swt.graphics.Rectangle bounds = children[i].getBounds(); |
| manualMove[i] = blit.width <= 0 || bounds.x > blit.x + blit.width |
| || bounds.y > blit.y + blit.height |
| || bounds.x + bounds.width < blit.x |
| || bounds.y + bounds.height < blit.y; |
| } |
| scroll(dest.x, dest.y, blit.x, blit.y, blit.width, blit.height, true); |
| for (int i = 0; i < children.length; i++) { |
| if (children[i].isDisposed()) |
| continue; |
| org.eclipse.swt.graphics.Rectangle bounds = children[i].getBounds(); |
| if (manualMove[i]) |
| children[i].setBounds(bounds.x + dx, bounds.y, bounds.width, |
| bounds.height); |
| } |
| |
| getViewport().setIgnoreScroll(true); |
| getViewport().setHorizontalLocation(hOffset); |
| getViewport().setIgnoreScroll(false); |
| getInnerCanvas().redraw(/*expose.x, expose.y, expose.width, |
| expose.height, true*/); |
| } |
| |
| /** |
| * Scrolls the contents vertically so that they are offset by |
| * <code>vOffset</code>. |
| * |
| * @param vOffset |
| * the new vertical offset |
| */ |
| public void scrollToY(int vOffset) { |
| vOffset = verifyScrollBarOffset(getViewport().getVerticalRangeModel(), |
| vOffset); |
| int vOffsetOld = getViewport().getViewLocation().y; |
| if (vOffset == vOffsetOld) |
| return; |
| int dy = -vOffset + vOffsetOld; |
| |
| Rectangle clientArea = getViewport().getBounds().getCropped( |
| getViewport().getInsets()); |
| Rectangle blit = clientArea.getResized(0, -Math.abs(dy)); |
| Rectangle expose = clientArea.getCopy(); |
| Point dest = clientArea.getTopLeft(); |
| expose.height = Math.abs(dy); |
| if (dy < 0) { // Moving up? |
| blit.translate(0, -dy); // Move blit area down |
| expose.y = dest.y + blit.height; // Move expose area down |
| } else |
| // Moving down |
| dest.y += dy; |
| |
| // fix for bug 41111 |
| Control[] children = getInnerCanvas().getChildren(); |
| boolean[] manualMove = new boolean[children.length]; |
| for (int i = 0; i < children.length; i++) { |
| org.eclipse.swt.graphics.Rectangle bounds = children[i].getBounds(); |
| manualMove[i] = blit.height <= 0 || bounds.x > blit.x + blit.width |
| || bounds.y > blit.y + blit.height |
| || bounds.x + bounds.width < blit.x |
| || bounds.y + bounds.height < blit.y; |
| } |
| scroll(dest.x, dest.y, blit.x, blit.y, blit.width, blit.height, true); |
| for (int i = 0; i < children.length; i++) { |
| if (children[i].isDisposed()) |
| continue; |
| org.eclipse.swt.graphics.Rectangle bounds = children[i].getBounds(); |
| if (manualMove[i]) |
| children[i].setBounds(bounds.x, bounds.y + dy, bounds.width, |
| bounds.height); |
| } |
| |
| getViewport().setIgnoreScroll(true); |
| getViewport().setVerticalLocation(vOffset); |
| getViewport().setIgnoreScroll(false); |
| getInnerCanvas().redraw(/*expose.x, expose.y, expose.width, |
| expose.height, true*/); |
| } |
| |
| public void scroll(int destX, int destY, int x, int y, int width, |
| int height, boolean all) { |
| checkWidget(); |
| int deltaX = destX - x, deltaY = destY - y; |
| if (all) { |
| Control[] children = getInnerCanvas().getChildren(); |
| for (int i = 0; i < children.length; i++) { |
| Control child = children[i]; |
| org.eclipse.swt.graphics.Rectangle rect = child.getBounds(); |
| if (Math.min(x + width, rect.x + rect.width) >= Math.max(x, |
| rect.x) |
| && Math.min(y + height, rect.y + rect.height) >= Math |
| .max(y, rect.y)) { |
| child.setLocation(rect.x + deltaX, rect.y + deltaY); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Sets the given border on the LightweightSystem's root figure. |
| * |
| * @param border |
| * The new border |
| */ |
| public void setBorder(Border border) { |
| getLightweightSystem().getRootFigure().setBorder(border); |
| } |
| |
| /** |
| * Sets the contents of the {@link Viewport}. |
| * |
| * @param figure |
| * the new contents |
| */ |
| public void setContents(IFigure figure) { |
| getViewport().setContents(figure); |
| } |
| |
| /** |
| * @see org.eclipse.swt.widgets.Control#setFont(org.eclipse.swt.graphics.Font) |
| */ |
| public void setFont(Font font) { |
| this.font = font; |
| super.setFont(font); |
| } |
| |
| public void setMenu(Menu menu) { |
| super.setMenu(menu); |
| getInnerCanvas().setMenu(menu); |
| } |
| |
| /** |
| * Sets the horizontal scrollbar visibility. Possible values are |
| * {@link #AUTOMATIC}, {@link #ALWAYS}, and {@link #NEVER}. |
| * |
| * @param v |
| * the new visibility |
| */ |
| public void setHorizontalScrollBarVisibility(int v) { |
| hBarVisibility = v; |
| } |
| |
| /** |
| * Sets both the horizontal and vertical scrollbar visibility to the given |
| * value. Possible values are {@link #AUTOMATIC}, {@link #ALWAYS}, and |
| * {@link #NEVER}. |
| * |
| * @param both |
| * the new visibility |
| */ |
| public void setScrollBarVisibility(int both) { |
| setHorizontalScrollBarVisibility(both); |
| setVerticalScrollBarVisibility(both); |
| } |
| |
| /** |
| * Sets the vertical scrollbar visibility. Possible values are |
| * {@link #AUTOMATIC}, {@link #ALWAYS}, and {@link #NEVER}. |
| * |
| * @param v |
| * the new visibility |
| */ |
| public void setVerticalScrollBarVisibility(int v) { |
| vBarVisibility = v; |
| } |
| |
| /** |
| * Sets the Viewport. The given Viewport must use "fake" scrolling. That is, |
| * it must be constructed using <code>new Viewport(true)</code>. |
| * |
| * @param vp |
| * the new viewport |
| */ |
| public void setViewport(Viewport vp) { |
| if (viewport != null) |
| unhookViewport(); |
| viewport = vp; |
| lws.setContents(viewport); |
| hookViewport(); |
| } |
| |
| private int verifyScrollBarOffset(RangeModel model, int value) { |
| value = Math.max(model.getMinimum(), value); |
| return Math.min(model.getMaximum() - model.getExtent(), value); |
| } |
| |
| public Slider getHorizontalSlider() { |
| checkWidget(); |
| if (horizontalBar == null) { |
| horizontalBar = new Slider(this, SWT.HORIZONTAL); |
| horizontalBar.setMaximum(100); |
| horizontalBar.setThumb(10); |
| } |
| return horizontalBar; |
| } |
| |
| public Slider getVerticalSlider() { |
| checkWidget(); |
| if (verticalBar == null) { |
| verticalBar = new Slider(this, SWT.VERTICAL); |
| verticalBar.setMaximum(100); |
| verticalBar.setThumb(10); |
| } |
| return verticalBar; |
| } |
| |
| } |