Java tutorial
/* * Copyright (C) 2009 The Android Open Source Project * * Licensed under the Eclipse Public License, Version 1.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/org/documents/epl-v10.php * * 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.android.ide.eclipse.adt.internal.editors.layout.gle2; import com.android.SdkConstants; import com.android.annotations.NonNull; import com.android.annotations.Nullable; import com.android.ide.common.api.IDragElement.IDragAttribute; import com.android.ide.common.api.INode; import com.android.ide.common.api.Margins; import com.android.ide.common.api.Point; import com.android.ide.common.rendering.api.Capability; import com.android.ide.common.rendering.api.RenderSession; import com.android.ide.eclipse.adt.AdtPlugin; import com.android.ide.eclipse.adt.internal.editors.descriptors.DescriptorsUtils; import com.android.ide.eclipse.adt.internal.editors.layout.LayoutEditorDelegate; import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationChooser; import com.android.ide.eclipse.adt.internal.editors.layout.configuration.ConfigurationDescription; import com.android.ide.eclipse.adt.internal.editors.layout.descriptors.ViewElementDescriptor; import com.android.ide.eclipse.adt.internal.editors.layout.gle2.IncludeFinder.Reference; import com.android.ide.eclipse.adt.internal.editors.layout.gre.NodeFactory; import com.android.ide.eclipse.adt.internal.editors.layout.gre.RulesEngine; import com.android.ide.eclipse.adt.internal.editors.layout.gre.ViewMetadataRepository; import com.android.ide.eclipse.adt.internal.editors.layout.uimodel.UiViewElementNode; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiDocumentNode; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; import com.android.ide.eclipse.adt.internal.lint.LintEditAction; import com.android.resources.Density; import org.eclipse.core.filesystem.EFS; import org.eclipse.core.filesystem.IFileStore; import org.eclipse.core.resources.IFile; import org.eclipse.core.resources.IWorkspaceRoot; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.QualifiedName; import org.eclipse.jdt.internal.ui.javaeditor.EditorUtility; import org.eclipse.jface.action.Action; import org.eclipse.jface.action.ActionContributionItem; import org.eclipse.jface.action.IAction; import org.eclipse.jface.action.IContributionItem; import org.eclipse.jface.action.IMenuManager; import org.eclipse.jface.action.IStatusLineManager; import org.eclipse.jface.action.MenuManager; import org.eclipse.jface.action.Separator; import org.eclipse.swt.SWT; import org.eclipse.swt.custom.StyledText; import org.eclipse.swt.dnd.DND; import org.eclipse.swt.dnd.DragSource; import org.eclipse.swt.dnd.DropTarget; import org.eclipse.swt.dnd.TextTransfer; import org.eclipse.swt.dnd.Transfer; import org.eclipse.swt.events.ControlAdapter; import org.eclipse.swt.events.ControlEvent; import org.eclipse.swt.events.KeyEvent; import org.eclipse.swt.events.MenuDetectEvent; import org.eclipse.swt.events.MenuDetectListener; import org.eclipse.swt.events.MouseEvent; import org.eclipse.swt.events.PaintEvent; import org.eclipse.swt.events.PaintListener; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.graphics.Font; import org.eclipse.swt.graphics.GC; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.ImageData; import org.eclipse.swt.graphics.Rectangle; 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.Menu; import org.eclipse.swt.widgets.Shell; import org.eclipse.ui.IActionBars; import org.eclipse.ui.IEditorPart; import org.eclipse.ui.IEditorSite; import org.eclipse.ui.IWorkbenchPage; import org.eclipse.ui.IWorkbenchWindow; import org.eclipse.ui.PartInitException; import org.eclipse.ui.actions.ActionFactory; import org.eclipse.ui.actions.ActionFactory.IWorkbenchAction; import org.eclipse.ui.actions.ContributionItemFactory; import org.eclipse.ui.ide.IDE; import org.eclipse.ui.internal.ide.IDEWorkbenchMessages; import org.eclipse.ui.texteditor.ITextEditor; import org.w3c.dom.Node; import java.util.HashSet; import java.util.List; import java.util.Set; /** * Displays the image rendered by the {@link GraphicalEditorPart} and handles * the interaction with the widgets. * <p/> * {@link LayoutCanvas} implements the "Canvas" control. The editor part * actually uses the {@link LayoutCanvasViewer}, which is a JFace viewer wrapper * around this control. * <p/> * The LayoutCanvas contains the painting logic for the canvas. Selection, * clipboard, view management etc. is handled in separate helper classes. * * @since GLE2 */ @SuppressWarnings("restriction") // For WorkBench "Show In" support public class LayoutCanvas extends Canvas { private final static QualifiedName NAME_ZOOM = new QualifiedName(AdtPlugin.PLUGIN_ID, "zoom");//$NON-NLS-1$ private static final boolean DEBUG = false; static final String PREFIX_CANVAS_ACTION = "canvas_action_"; //$NON-NLS-1$ /** The layout editor that uses this layout canvas. */ private final LayoutEditorDelegate mEditorDelegate; /** The Rules Engine, associated with the current project. */ private RulesEngine mRulesEngine; /** GC wrapper given to the IViewRule methods. The GC itself is only defined in the * context of {@link #onPaint(PaintEvent)}; otherwise it is null. */ private GCWrapper mGCWrapper; /** Default font used on the canvas. Do not dispose, it's a system font. */ private Font mFont; /** Current hover view info. Null when no mouse hover. */ private CanvasViewInfo mHoverViewInfo; /** When true, always display the outline of all views. */ private boolean mShowOutline; /** When true, display the outline of all empty parent views. */ private boolean mShowInvisible; /** Drop target associated with this composite. */ private DropTarget mDropTarget; /** Factory that can create {@link INode} proxies. */ private final @NonNull NodeFactory mNodeFactory = new NodeFactory(this); /** Vertical scaling & scrollbar information. */ private final CanvasTransform mVScale; /** Horizontal scaling & scrollbar information. */ private final CanvasTransform mHScale; /** Drag source associated with this canvas. */ private DragSource mDragSource; /** * The current Outline Page, to set its model. * It isn't possible to call OutlinePage2.dispose() in this.dispose(). * this.dispose() is called from GraphicalEditorPart.dispose(), * when page's widget is already disposed. * Added the DisposeListener to OutlinePage2 in order to correctly dispose this page. **/ private OutlinePage mOutlinePage; /** Delete action for the Edit or context menu. */ private Action mDeleteAction; /** Select-All action for the Edit or context menu. */ private Action mSelectAllAction; /** Paste action for the Edit or context menu. */ private Action mPasteAction; /** Cut action for the Edit or context menu. */ private Action mCutAction; /** Copy action for the Edit or context menu. */ private Action mCopyAction; /** Undo action: delegates to the text editor */ private IAction mUndoAction; /** Redo action: delegates to the text editor */ private IAction mRedoAction; /** Root of the context menu. */ private MenuManager mMenuManager; /** The view hierarchy associated with this canvas. */ private final ViewHierarchy mViewHierarchy = new ViewHierarchy(this); /** The selection in the canvas. */ private final SelectionManager mSelectionManager = new SelectionManager(this); /** The overlay which paints the optional outline. */ private OutlineOverlay mOutlineOverlay; /** The overlay which paints outlines around empty children */ private EmptyViewsOverlay mEmptyOverlay; /** The overlay which paints the mouse hover. */ private HoverOverlay mHoverOverlay; /** The overlay which paints the lint warnings */ private LintOverlay mLintOverlay; /** The overlay which paints the selection. */ private SelectionOverlay mSelectionOverlay; /** The overlay which paints the rendered layout image. */ private ImageOverlay mImageOverlay; /** The overlay which paints masks hiding everything but included content. */ private IncludeOverlay mIncludeOverlay; /** Configuration previews shown next to the layout */ private final RenderPreviewManager mPreviewManager; /** * Gesture Manager responsible for identifying mouse, keyboard and drag and * drop events. */ private final GestureManager mGestureManager = new GestureManager(this); /** * When set, performs a zoom-to-fit when the next rendering image arrives. */ private boolean mZoomFitNextImage; /** * Native clipboard support. */ private ClipboardSupport mClipboardSupport; /** Tooltip manager for lint warnings */ private LintTooltipManager mLintTooltipManager; private Color mBackgroundColor; /** * Creates a new {@link LayoutCanvas} widget * * @param editorDelegate the associated editor delegate * @param rulesEngine the rules engine * @param parent parent SWT widget * @param style the SWT style */ public LayoutCanvas(LayoutEditorDelegate editorDelegate, RulesEngine rulesEngine, Composite parent, int style) { super(parent, style | SWT.DOUBLE_BUFFERED | SWT.V_SCROLL | SWT.H_SCROLL); mEditorDelegate = editorDelegate; mRulesEngine = rulesEngine; mBackgroundColor = new Color(parent.getDisplay(), 150, 150, 150); setBackground(mBackgroundColor); mClipboardSupport = new ClipboardSupport(this, parent); mHScale = new CanvasTransform(this, getHorizontalBar()); mVScale = new CanvasTransform(this, getVerticalBar()); mPreviewManager = new RenderPreviewManager(this); // Unit test suite passes a null here; TODO: Replace with mocking IFile file = editorDelegate != null ? editorDelegate.getEditor().getInputFile() : null; if (file != null) { String zoom = AdtPlugin.getFileProperty(file, NAME_ZOOM); if (zoom != null) { try { double initialScale = Double.parseDouble(zoom); if (initialScale > 0.1) { mHScale.setScale(initialScale); mVScale.setScale(initialScale); } } catch (NumberFormatException nfe) { // Ignore - use zoom=100% } } else { mZoomFitNextImage = true; } } mGCWrapper = new GCWrapper(mHScale, mVScale); Display display = getDisplay(); mFont = display.getSystemFont(); // --- Set up graphic overlays // mOutlineOverlay and mEmptyOverlay are initialized lazily mHoverOverlay = new HoverOverlay(this, mHScale, mVScale); mHoverOverlay.create(display); mSelectionOverlay = new SelectionOverlay(this); mSelectionOverlay.create(display); mImageOverlay = new ImageOverlay(this, mHScale, mVScale); mIncludeOverlay = new IncludeOverlay(this); mImageOverlay.create(display); mLintOverlay = new LintOverlay(this); mLintOverlay.create(display); // --- Set up listeners addPaintListener(new PaintListener() { @Override public void paintControl(PaintEvent e) { onPaint(e); } }); addControlListener(new ControlAdapter() { @Override public void controlResized(ControlEvent e) { super.controlResized(e); // Check editor state: LayoutWindowCoordinator coordinator = null; IEditorSite editorSite = getEditorDelegate().getEditor().getEditorSite(); IWorkbenchWindow window = editorSite.getWorkbenchWindow(); if (window != null) { coordinator = LayoutWindowCoordinator.get(window, false); if (coordinator != null) { coordinator.syncMaximizedState(editorSite.getPage()); } } updateScrollBars(); // Update the zoom level in the canvas when you toggle the zoom if (coordinator != null) { mZoomCheck.run(); } else { // During startup, delay updates which can trigger further layout getDisplay().asyncExec(mZoomCheck); } } }); // --- setup drag'n'drop --- // DND Reference: http://www.eclipse.org/articles/Article-SWT-DND/DND-in-SWT.html mDropTarget = createDropTarget(this); mDragSource = createDragSource(this); mGestureManager.registerListeners(mDragSource, mDropTarget); if (mEditorDelegate == null) { // TODO: In another CL we should use EasyMock/objgen to provide an editor. return; // Unit test } // --- setup context menu --- setupGlobalActionHandlers(); createContextMenu(); // --- setup outline --- // Get the outline associated with this editor, if any and of the right type. if (editorDelegate != null) { mOutlinePage = editorDelegate.getGraphicalOutline(); } mLintTooltipManager = new LintTooltipManager(this); mLintTooltipManager.register(); } void updateScrollBars() { Rectangle clientArea = getClientArea(); Image image = mImageOverlay.getImage(); if (image != null) { ImageData imageData = image.getImageData(); int clientWidth = clientArea.width; int clientHeight = clientArea.height; int imageWidth = imageData.width; int imageHeight = imageData.height; int fullWidth = imageWidth; int fullHeight = imageHeight; if (mPreviewManager.hasPreviews()) { fullHeight = Math.max(fullHeight, (int) (mPreviewManager.getHeight() / mHScale.getScale())); } if (clientWidth == 0) { clientWidth = imageWidth; Shell shell = getShell(); if (shell != null) { org.eclipse.swt.graphics.Point size = shell.getSize(); if (size.x > 0) { clientWidth = size.x * 70 / 100; } } } if (clientHeight == 0) { clientHeight = imageHeight; Shell shell = getShell(); if (shell != null) { org.eclipse.swt.graphics.Point size = shell.getSize(); if (size.y > 0) { clientWidth = size.y * 80 / 100; } } } mHScale.setSize(imageWidth, fullWidth, clientWidth); mVScale.setSize(imageHeight, fullHeight, clientHeight); } } private Runnable mZoomCheck = new Runnable() { private Boolean mWasZoomed; @Override public void run() { if (isDisposed()) { return; } IEditorSite editorSite = getEditorDelegate().getEditor().getEditorSite(); IWorkbenchWindow window = editorSite.getWorkbenchWindow(); if (window != null) { LayoutWindowCoordinator coordinator = LayoutWindowCoordinator.get(window, false); if (coordinator != null) { Boolean zoomed = coordinator.isEditorMaximized(); if (mWasZoomed != zoomed) { if (mWasZoomed != null) { LayoutActionBar actionBar = getGraphicalEditor().getLayoutActionBar(); if (actionBar.isZoomingAllowed()) { setFitScale(true /*onlyZoomOut*/, true /*allowZoomIn*/); } } mWasZoomed = zoomed; } } } } }; void handleKeyPressed(KeyEvent e) { // Set up backspace as an alias for the delete action within the canvas. // On most Macs there is no delete key - though there IS a key labeled // "Delete" and it sends a backspace key code! In short, for Macs we should // treat backspace as delete, and it's harmless (and probably useful) to // handle backspace for other platforms as well. if (e.keyCode == SWT.BS) { mDeleteAction.run(); } else if (e.keyCode == SWT.ESC) { mSelectionManager.selectParent(); } else if (e.keyCode == DynamicContextMenu.DEFAULT_ACTION_KEY) { mSelectionManager.performDefaultAction(); } else if (e.keyCode == 'r') { // Keep key bindings in sync with {@link DynamicContextMenu#createPlainAction} // TODO: Find a way to look up the Eclipse key bindings and attempt // to use the current keymap's rename action. if (SdkConstants.CURRENT_PLATFORM == SdkConstants.PLATFORM_DARWIN) { // Command+Option+R if ((e.stateMask & (SWT.MOD1 | SWT.MOD3)) == (SWT.MOD1 | SWT.MOD3)) { mSelectionManager.performRename(); } } else { // Alt+Shift+R if ((e.stateMask & (SWT.MOD2 | SWT.MOD3)) == (SWT.MOD2 | SWT.MOD3)) { mSelectionManager.performRename(); } } } else { // Zooming actions char c = e.character; LayoutActionBar actionBar = getGraphicalEditor().getLayoutActionBar(); if (c == '1' && actionBar.isZoomingAllowed()) { setScale(1, true); } else if (c == '0' && actionBar.isZoomingAllowed()) { setFitScale(true, true /*allowZoomIn*/); } else if (e.keyCode == '0' && (e.stateMask & SWT.MOD2) != 0 && actionBar.isZoomingAllowed()) { setFitScale(false, true /*allowZoomIn*/); } else if ((c == '+' || c == '=') && actionBar.isZoomingAllowed()) { if ((e.stateMask & SWT.MOD1) != 0) { mPreviewManager.zoomIn(); } else { actionBar.rescale(1); } } else if (c == '-' && actionBar.isZoomingAllowed()) { if ((e.stateMask & SWT.MOD1) != 0) { mPreviewManager.zoomOut(); } else { actionBar.rescale(-1); } } } } @Override public void dispose() { super.dispose(); mGestureManager.unregisterListeners(mDragSource, mDropTarget); if (mLintTooltipManager != null) { mLintTooltipManager.unregister(); mLintTooltipManager = null; } if (mDropTarget != null) { mDropTarget.dispose(); mDropTarget = null; } if (mRulesEngine != null) { mRulesEngine.dispose(); mRulesEngine = null; } if (mDragSource != null) { mDragSource.dispose(); mDragSource = null; } if (mClipboardSupport != null) { mClipboardSupport.dispose(); mClipboardSupport = null; } if (mGCWrapper != null) { mGCWrapper.dispose(); mGCWrapper = null; } if (mOutlineOverlay != null) { mOutlineOverlay.dispose(); mOutlineOverlay = null; } if (mEmptyOverlay != null) { mEmptyOverlay.dispose(); mEmptyOverlay = null; } if (mHoverOverlay != null) { mHoverOverlay.dispose(); mHoverOverlay = null; } if (mSelectionOverlay != null) { mSelectionOverlay.dispose(); mSelectionOverlay = null; } if (mImageOverlay != null) { mImageOverlay.dispose(); mImageOverlay = null; } if (mIncludeOverlay != null) { mIncludeOverlay.dispose(); mIncludeOverlay = null; } if (mLintOverlay != null) { mLintOverlay.dispose(); mLintOverlay = null; } if (mBackgroundColor != null) { mBackgroundColor.dispose(); mBackgroundColor = null; } mPreviewManager.disposePreviews(); mViewHierarchy.dispose(); } /** * Returns the configuration preview manager for this canvas * * @return the configuration preview manager for this canvas */ @NonNull public RenderPreviewManager getPreviewManager() { return mPreviewManager; } /** Returns the Rules Engine, associated with the current project. */ RulesEngine getRulesEngine() { return mRulesEngine; } /** Sets the Rules Engine, associated with the current project. */ void setRulesEngine(RulesEngine rulesEngine) { mRulesEngine = rulesEngine; } /** * Returns the factory to use to convert from {@link CanvasViewInfo} or from * {@link UiViewElementNode} to {@link INode} proxies. * * @return the node factory */ @NonNull public NodeFactory getNodeFactory() { return mNodeFactory; } /** * Returns the GCWrapper used to paint view rules. * * @return The GCWrapper used to paint view rules */ GCWrapper getGcWrapper() { return mGCWrapper; } /** * Returns the {@link LayoutEditorDelegate} associated with this canvas. * * @return the delegate */ public LayoutEditorDelegate getEditorDelegate() { return mEditorDelegate; } /** * Returns the current {@link ImageOverlay} painting the rendered result * * @return the image overlay responsible for painting the rendered result, never null */ ImageOverlay getImageOverlay() { return mImageOverlay; } /** * Returns the current {@link SelectionOverlay} painting the selection highlights * * @return the selection overlay responsible for painting the selection highlights, * never null */ SelectionOverlay getSelectionOverlay() { return mSelectionOverlay; } /** * Returns the {@link GestureManager} associated with this canvas. * * @return the {@link GestureManager} associated with this canvas, never null. */ GestureManager getGestureManager() { return mGestureManager; } /** * Returns the current {@link HoverOverlay} painting the mouse hover. * * @return the hover overlay responsible for painting the mouse hover, * never null */ HoverOverlay getHoverOverlay() { return mHoverOverlay; } /** * Returns the horizontal {@link CanvasTransform} transform object, which can map * a layout point into a control point. * * @return A {@link CanvasTransform} for mapping between layout and control * coordinates in the horizontal dimension. */ CanvasTransform getHorizontalTransform() { return mHScale; } /** * Returns the vertical {@link CanvasTransform} transform object, which can map a * layout point into a control point. * * @return A {@link CanvasTransform} for mapping between layout and control * coordinates in the vertical dimension. */ CanvasTransform getVerticalTransform() { return mVScale; } /** * Returns the {@link OutlinePage} associated with this canvas * * @return the {@link OutlinePage} associated with this canvas */ public OutlinePage getOutlinePage() { return mOutlinePage; } /** * Returns the {@link SelectionManager} associated with this canvas. * * @return The {@link SelectionManager} holding the selection for this * canvas. Never null. */ public SelectionManager getSelectionManager() { return mSelectionManager; } /** * Returns the {@link ViewHierarchy} object associated with this canvas, * holding the most recent rendered view of the scene, if valid. * * @return The {@link ViewHierarchy} object associated with this canvas. * Never null. */ public ViewHierarchy getViewHierarchy() { return mViewHierarchy; } /** * Returns the {@link ClipboardSupport} object associated with this canvas. * * @return The {@link ClipboardSupport} object for this canvas. Null only after dispose. */ public ClipboardSupport getClipboardSupport() { return mClipboardSupport; } /** Returns the Select All action bound to this canvas */ Action getSelectAllAction() { return mSelectAllAction; } /** Returns the associated {@link GraphicalEditorPart} */ GraphicalEditorPart getGraphicalEditor() { return mEditorDelegate.getGraphicalEditor(); } /** * Sets the result of the layout rendering. The result object indicates if the layout * rendering succeeded. If it did, it contains a bitmap and the objects rectangles. * * Implementation detail: the bridge's computeLayout() method already returns a newly * allocated ILayourResult. That means we can keep this result and hold on to it * when it is valid. * * @param session The new scene, either valid or not. * @param explodedNodes The set of individual nodes the layout computer was asked to * explode. Note that these are independent of the explode-all mode where * all views are exploded; this is used only for the mode ( * {@link #showInvisibleViews(boolean)}) where individual invisible nodes * are padded during certain interactions. */ void setSession(RenderSession session, Set<UiElementNode> explodedNodes, boolean layoutlib5) { // disable any hover clearHover(); mViewHierarchy.setSession(session, explodedNodes, layoutlib5); if (mViewHierarchy.isValid() && session != null) { Image image = mImageOverlay.setImage(session.getImage(), session.isAlphaChannelImage()); mOutlinePage.setModel(mViewHierarchy.getRoot()); getGraphicalEditor().setModel(mViewHierarchy.getRoot()); if (image != null) { updateScrollBars(); if (mZoomFitNextImage) { // Must be run asynchronously because getClientArea() returns 0 bounds // when the editor is being initialized getDisplay().asyncExec(new Runnable() { @Override public void run() { if (!isDisposed()) { ensureZoomed(); } } }); } // Ensure that if we have a a preview mode enabled, it's shown syncPreviewMode(); } } redraw(); } void ensureZoomed() { if (mZoomFitNextImage && getClientArea().height > 0) { mZoomFitNextImage = false; LayoutActionBar actionBar = getGraphicalEditor().getLayoutActionBar(); if (actionBar.isZoomingAllowed()) { setFitScale(true, true /*allowZoomIn*/); } } } void setShowOutline(boolean newState) { mShowOutline = newState; redraw(); } /** * Returns the zoom scale factor of the canvas (the amount the full * resolution render of the device is zoomed before being shown on the * canvas) * * @return the image scale */ public double getScale() { return mHScale.getScale(); } void setScale(double scale, boolean redraw) { if (scale <= 0.0) { scale = 1.0; } if (scale == getScale()) { return; } mHScale.setScale(scale); mVScale.setScale(scale); if (redraw) { redraw(); } // Clear the zoom setting if it is almost identical to 1.0 String zoomValue = (Math.abs(scale - 1.0) < 0.0001) ? null : Double.toString(scale); IFile file = mEditorDelegate.getEditor().getInputFile(); if (file != null) { AdtPlugin.setFileProperty(file, NAME_ZOOM, zoomValue); } } /** * Scales the canvas to best fit * * @param onlyZoomOut if true, then the zooming factor will never be larger than 1, * which means that this function will zoom out if necessary to show the * rendered image, but it will never zoom in. * TODO: Rename this, it sounds like it conflicts with allowZoomIn, * even though one is referring to the zoom level and one is referring * to the overall act of scaling above/below 1. * @param allowZoomIn if false, then if the computed zoom factor is smaller than * the current zoom factor, it will be ignored. */ public void setFitScale(boolean onlyZoomOut, boolean allowZoomIn) { ImageOverlay imageOverlay = getImageOverlay(); if (imageOverlay == null) { return; } Image image = imageOverlay.getImage(); if (image != null) { Rectangle canvasSize = getClientArea(); int canvasWidth = canvasSize.width; int canvasHeight = canvasSize.height; boolean hasPreviews = mPreviewManager.hasPreviews(); if (hasPreviews) { canvasWidth = 2 * canvasWidth / 3; } else { canvasWidth -= 4; canvasHeight -= 4; } ImageData imageData = image.getImageData(); int sceneWidth = imageData.width; int sceneHeight = imageData.height; if (sceneWidth == 0.0 || sceneHeight == 0.0) { return; } if (imageOverlay.getShowDropShadow()) { sceneWidth += 2 * ImageUtils.SHADOW_SIZE; sceneHeight += 2 * ImageUtils.SHADOW_SIZE; } // Reduce the margins if necessary int hDelta = canvasWidth - sceneWidth; int hMargin = 0; if (hDelta > 2 * CanvasTransform.DEFAULT_MARGIN) { hMargin = CanvasTransform.DEFAULT_MARGIN; } else if (hDelta > 0) { hMargin = hDelta / 2; } int vDelta = canvasHeight - sceneHeight; int vMargin = 0; if (vDelta > 2 * CanvasTransform.DEFAULT_MARGIN) { vMargin = CanvasTransform.DEFAULT_MARGIN; } else if (vDelta > 0) { vMargin = vDelta / 2; } double hScale = (canvasWidth - 2 * hMargin) / (double) sceneWidth; double vScale = (canvasHeight - 2 * vMargin) / (double) sceneHeight; double scale = Math.min(hScale, vScale); if (onlyZoomOut) { scale = Math.min(1.0, scale); } if (!allowZoomIn && scale > getScale()) { return; } setScale(scale, true); } } /** * Transforms a point, expressed in layout coordinates, into "client" coordinates * relative to the control (and not relative to the display). * * @param canvasX X in the canvas coordinates * @param canvasY Y in the canvas coordinates * @return A new {@link Point} in control client coordinates (not display coordinates) */ Point layoutToControlPoint(int canvasX, int canvasY) { int x = mHScale.translate(canvasX); int y = mVScale.translate(canvasY); return new Point(x, y); } /** * Returns the action for the context menu corresponding to the given action id. * <p/> * For global actions such as copy or paste, the action id must be composed of * the {@link #PREFIX_CANVAS_ACTION} followed by one of {@link ActionFactory}'s * action ids. * <p/> * Returns null if there's no action for the given id. */ IAction getAction(String actionId) { String prefix = PREFIX_CANVAS_ACTION; if (mMenuManager == null || actionId == null || !actionId.startsWith(prefix)) { return null; } actionId = actionId.substring(prefix.length()); for (IContributionItem contrib : mMenuManager.getItems()) { if (contrib instanceof ActionContributionItem && actionId.equals(contrib.getId())) { return ((ActionContributionItem) contrib).getAction(); } } return null; } //--------------- /** * Paints the canvas in response to paint events. */ private void onPaint(PaintEvent e) { GC gc = e.gc; gc.setFont(mFont); mGCWrapper.setGC(gc); try { if (!mImageOverlay.isHiding()) { mImageOverlay.paint(gc); } mPreviewManager.paint(gc); if (mShowOutline) { if (mOutlineOverlay == null) { mOutlineOverlay = new OutlineOverlay(mViewHierarchy, mHScale, mVScale); mOutlineOverlay.create(getDisplay()); } if (!mOutlineOverlay.isHiding()) { mOutlineOverlay.paint(gc); } } if (mShowInvisible) { if (mEmptyOverlay == null) { mEmptyOverlay = new EmptyViewsOverlay(mViewHierarchy, mHScale, mVScale); mEmptyOverlay.create(getDisplay()); } if (!mEmptyOverlay.isHiding()) { mEmptyOverlay.paint(gc); } } if (!mHoverOverlay.isHiding()) { mHoverOverlay.paint(gc); } if (!mLintOverlay.isHiding()) { mLintOverlay.paint(gc); } if (!mIncludeOverlay.isHiding()) { mIncludeOverlay.paint(gc); } if (!mSelectionOverlay.isHiding()) { mSelectionOverlay.paint(mSelectionManager, mGCWrapper, gc, mRulesEngine); } mGestureManager.paint(gc); } finally { mGCWrapper.setGC(null); } } /** * Shows or hides invisible parent views, which are views which have empty bounds and * no children. The nodes which will be shown are provided by * {@link #getNodesToExplode()}. * * @param show When true, any invisible parent nodes are padded and highlighted * ("exploded"), and when false any formerly exploded nodes are hidden. */ void showInvisibleViews(boolean show) { if (mShowInvisible == show) { return; } mShowInvisible = show; // Optimization: Avoid doing work when we don't have invisible parents (on show) // or formerly exploded nodes (on hide). if (show && !mViewHierarchy.hasInvisibleParents()) { return; } else if (!show && !mViewHierarchy.hasExplodedParents()) { return; } mEditorDelegate.recomputeLayout(); } /** * Returns a set of nodes that should be exploded (forced non-zero padding during render), * or null if no nodes should be exploded. (Note that this is independent of the * explode-all mode, where all nodes are padded -- that facility does not use this * mechanism, which is only intended to be used to expose invisible parent nodes. * * @return The set of invisible parents, or null if no views should be expanded. */ public Set<UiElementNode> getNodesToExplode() { if (mShowInvisible) { return mViewHierarchy.getInvisibleNodes(); } // IF we have selection, and IF we have invisible nodes in the view, // see if any of the selected items are among the invisible nodes, and if so // add them to a lazily constructed set which we pass back for rendering. Set<UiElementNode> result = null; List<SelectionItem> selections = mSelectionManager.getSelections(); if (selections.size() > 0) { List<CanvasViewInfo> invisibleParents = mViewHierarchy.getInvisibleViews(); if (invisibleParents.size() > 0) { for (SelectionItem item : selections) { CanvasViewInfo viewInfo = item.getViewInfo(); // O(n^2) here, but both the selection size and especially the // invisibleParents size are expected to be small if (invisibleParents.contains(viewInfo)) { UiViewElementNode node = viewInfo.getUiViewNode(); if (node != null) { if (result == null) { result = new HashSet<UiElementNode>(); } result.add(node); } } } } } return result; } /** * Clears the hover. */ void clearHover() { mHoverOverlay.clearHover(); } /** * Hover on top of a known child. */ void hover(MouseEvent e) { // Check if a button is pressed; no hovers during drags if ((e.stateMask & SWT.BUTTON_MASK) != 0) { clearHover(); return; } LayoutPoint p = ControlPoint.create(this, e).toLayout(); CanvasViewInfo vi = mViewHierarchy.findViewInfoAt(p); // We don't hover on the root since it's not a widget per see and it is always there. // We also skip spacers... if (vi != null && (vi.isRoot() || vi.isHidden())) { vi = null; } boolean needsUpdate = vi != mHoverViewInfo; mHoverViewInfo = vi; if (vi == null) { clearHover(); } else { Rectangle r = vi.getSelectionRect(); mHoverOverlay.setHover(r.x, r.y, r.width, r.height); } if (needsUpdate) { redraw(); } } /** * Shows the given {@link CanvasViewInfo}, which can mean exposing its XML or if it's * an included element, its corresponding file. * * @param vi the {@link CanvasViewInfo} to be shown */ public void show(CanvasViewInfo vi) { String url = vi.getIncludeUrl(); if (url != null) { showInclude(url); } else { showXml(vi); } } /** * Shows the layout file referenced by the given url in the same project. * * @param url The layout attribute url of the form @layout/foo */ private void showInclude(String url) { GraphicalEditorPart graphicalEditor = getGraphicalEditor(); IPath filePath = graphicalEditor.findResourceFile(url); if (filePath == null) { // Should not be possible - if the URL had been bad, then we wouldn't // have been able to render the scene and you wouldn't have been able // to click on it return; } // Save the including file, if necessary: without it, the "Show Included In" // facility which is invoked automatically will not work properly if the <include> // tag is not in the saved version of the file, since the outer file is read from // disk rather than from memory. IEditorSite editorSite = graphicalEditor.getEditorSite(); IWorkbenchPage page = editorSite.getPage(); page.saveEditor(mEditorDelegate.getEditor(), false); IWorkspaceRoot workspace = ResourcesPlugin.getWorkspace().getRoot(); IFile xmlFile = null; IPath workspacePath = workspace.getLocation(); if (workspacePath.isPrefixOf(filePath)) { IPath relativePath = filePath.makeRelativeTo(workspacePath); xmlFile = (IFile) workspace.findMember(relativePath); } else if (filePath.isAbsolute()) { xmlFile = workspace.getFileForLocation(filePath); } if (xmlFile != null) { IFile leavingFile = graphicalEditor.getEditedFile(); Reference next = Reference.create(graphicalEditor.getEditedFile()); try { IEditorPart openAlready = EditorUtility.isOpenInEditor(xmlFile); // Show the included file as included within this click source? if (openAlready != null) { LayoutEditorDelegate delegate = LayoutEditorDelegate.fromEditor(openAlready); if (delegate != null) { GraphicalEditorPart gEditor = delegate.getGraphicalEditor(); if (gEditor != null && gEditor.renderingSupports(Capability.EMBEDDED_LAYOUT)) { gEditor.showIn(next); } } } else { try { // Set initial state of a new file // TODO: Only set rendering target portion of the state String state = ConfigurationDescription.getDescription(leavingFile); xmlFile.setSessionProperty(GraphicalEditorPart.NAME_INITIAL_STATE, state); } catch (CoreException e) { // pass } if (graphicalEditor.renderingSupports(Capability.EMBEDDED_LAYOUT)) { try { xmlFile.setSessionProperty(GraphicalEditorPart.NAME_INCLUDE, next); } catch (CoreException e) { // pass - worst that can happen is that we don't //start with inclusion } } } EditorUtility.openInEditor(xmlFile, true); return; } catch (PartInitException ex) { AdtPlugin.log(ex, "Can't open %$1s", url); //$NON-NLS-1$ } } else { // It's not a path in the workspace; look externally // (this is probably an @android: path) if (filePath.isAbsolute()) { IFileStore fileStore = EFS.getLocalFileSystem().getStore(filePath); // fileStore = fileStore.getChild(names[i]); if (!fileStore.fetchInfo().isDirectory() && fileStore.fetchInfo().exists()) { try { IDE.openEditorOnFileStore(page, fileStore); return; } catch (PartInitException ex) { AdtPlugin.log(ex, "Can't open %$1s", url); //$NON-NLS-1$ } } } } // Failed: display message to the user String message = String.format("Could not find resource %1$s", url); IStatusLineManager status = editorSite.getActionBars().getStatusLineManager(); status.setErrorMessage(message); getDisplay().beep(); } /** * Returns the layout resource name of this layout * * @return the layout resource name of this layout */ public String getLayoutResourceName() { GraphicalEditorPart graphicalEditor = getGraphicalEditor(); return graphicalEditor.getLayoutResourceName(); } /** * Returns the layout resource url of the current layout * * @return */ /* public String getMe() { GraphicalEditorPart graphicalEditor = getGraphicalEditor(); IFile editedFile = graphicalEditor.getEditedFile(); return editedFile.getProjectRelativePath().toOSString(); } */ /** * Show the XML element corresponding to the given {@link CanvasViewInfo} (unless it's * a root). * * @param vi The clicked {@link CanvasViewInfo} whose underlying XML element we want * to view */ private void showXml(CanvasViewInfo vi) { // Warp to the text editor and show the corresponding XML for the // double-clicked widget if (vi.isRoot()) { return; } Node xmlNode = vi.getXmlNode(); if (xmlNode != null) { boolean found = mEditorDelegate.getEditor().show(xmlNode); if (!found) { getDisplay().beep(); } } } //--------------- /** * Helper to create the drag source for the given control. * <p/> * This is static with package-access so that {@link OutlinePage} can also * create an exact copy of the source with the same attributes. */ /* package */static DragSource createDragSource(Control control) { DragSource source = new DragSource(control, DND.DROP_COPY | DND.DROP_MOVE); source.setTransfer(new Transfer[] { TextTransfer.getInstance(), SimpleXmlTransfer.getInstance() }); return source; } /** * Helper to create the drop target for the given control. */ private static DropTarget createDropTarget(Control control) { DropTarget dropTarget = new DropTarget(control, DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_DEFAULT); dropTarget.setTransfer(new Transfer[] { SimpleXmlTransfer.getInstance() }); return dropTarget; } //--------------- /** * Invoked by the constructor to add our cut/copy/paste/delete/select-all * handlers in the global action handlers of this editor's site. * <p/> * This will enable the menu items under the global Edit menu and make them * invoke our actions as needed. As a benefit, the corresponding shortcut * accelerators will do what one would expect. */ private void setupGlobalActionHandlers() { mCutAction = new Action() { @Override public void run() { mClipboardSupport.cutSelectionToClipboard(mSelectionManager.getSnapshot()); updateMenuActionState(); } }; copyActionAttributes(mCutAction, ActionFactory.CUT); mCopyAction = new Action() { @Override public void run() { mClipboardSupport.copySelectionToClipboard(mSelectionManager.getSnapshot()); updateMenuActionState(); } }; copyActionAttributes(mCopyAction, ActionFactory.COPY); mPasteAction = new Action() { @Override public void run() { mClipboardSupport.pasteSelection(mSelectionManager.getSnapshot()); updateMenuActionState(); } }; copyActionAttributes(mPasteAction, ActionFactory.PASTE); mDeleteAction = new Action() { @Override public void run() { mClipboardSupport.deleteSelection(getDeleteLabel(), mSelectionManager.getSnapshot()); } }; copyActionAttributes(mDeleteAction, ActionFactory.DELETE); mSelectAllAction = new Action() { @Override public void run() { GraphicalEditorPart graphicalEditor = getEditorDelegate().getGraphicalEditor(); StyledText errorLabel = graphicalEditor.getErrorLabel(); if (errorLabel.isFocusControl()) { errorLabel.selectAll(); return; } mSelectionManager.selectAll(); } }; copyActionAttributes(mSelectAllAction, ActionFactory.SELECT_ALL); } String getCutLabel() { return mCutAction.getText(); } String getDeleteLabel() { // verb "Delete" from the DELETE action's title return mDeleteAction.getText(); } /** * Updates menu actions that depends on the selection. */ void updateMenuActionState() { List<SelectionItem> selections = getSelectionManager().getSelections(); boolean hasSelection = !selections.isEmpty(); if (hasSelection && selections.size() == 1 && selections.get(0).isRoot()) { hasSelection = false; } StyledText errorLabel = getGraphicalEditor().getErrorLabel(); mCutAction.setEnabled(hasSelection); mCopyAction.setEnabled(hasSelection || errorLabel.getSelectionCount() > 0); mDeleteAction.setEnabled(hasSelection); // Select All should *always* be selectable, regardless of whether anything // is currently selected. mSelectAllAction.setEnabled(true); // The paste operation is only available if we can paste our custom type. // We do not currently support pasting random text (e.g. XML). Maybe later. boolean hasSxt = mClipboardSupport.hasSxtOnClipboard(); mPasteAction.setEnabled(hasSxt); } /** * Update the actions when this editor is activated * * @param bars the action bar for this canvas */ public void updateGlobalActions(@NonNull IActionBars bars) { updateMenuActionState(); ITextEditor editor = mEditorDelegate.getEditor().getStructuredTextEditor(); boolean graphical = getEditorDelegate().getEditor().getActivePage() == 0; if (graphical) { bars.setGlobalActionHandler(ActionFactory.CUT.getId(), mCutAction); bars.setGlobalActionHandler(ActionFactory.COPY.getId(), mCopyAction); bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), mPasteAction); bars.setGlobalActionHandler(ActionFactory.DELETE.getId(), mDeleteAction); bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), mSelectAllAction); // Delegate the Undo and Redo actions to the text editor ones, but wrap them // such that we run lint to update the results on the current page (this is // normally done on each editor operation that goes through // {@link AndroidXmlEditor#wrapUndoEditXmlModel}, but not undo/redo) if (mUndoAction == null) { IAction undoAction = editor.getAction(ActionFactory.UNDO.getId()); mUndoAction = new LintEditAction(undoAction, getEditorDelegate().getEditor()); } bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), mUndoAction); if (mRedoAction == null) { IAction redoAction = editor.getAction(ActionFactory.REDO.getId()); mRedoAction = new LintEditAction(redoAction, getEditorDelegate().getEditor()); } bars.setGlobalActionHandler(ActionFactory.REDO.getId(), mRedoAction); } else { bars.setGlobalActionHandler(ActionFactory.CUT.getId(), editor.getAction(ActionFactory.CUT.getId())); bars.setGlobalActionHandler(ActionFactory.COPY.getId(), editor.getAction(ActionFactory.COPY.getId())); bars.setGlobalActionHandler(ActionFactory.PASTE.getId(), editor.getAction(ActionFactory.PASTE.getId())); bars.setGlobalActionHandler(ActionFactory.DELETE.getId(), editor.getAction(ActionFactory.DELETE.getId())); bars.setGlobalActionHandler(ActionFactory.SELECT_ALL.getId(), editor.getAction(ActionFactory.SELECT_ALL.getId())); bars.setGlobalActionHandler(ActionFactory.UNDO.getId(), editor.getAction(ActionFactory.UNDO.getId())); bars.setGlobalActionHandler(ActionFactory.REDO.getId(), editor.getAction(ActionFactory.REDO.getId())); } bars.updateActionBars(); } /** * Helper for {@link #setupGlobalActionHandlers()}. * Copies the action attributes form the given {@link ActionFactory}'s action to * our action. * <p/> * {@link ActionFactory} provides access to the standard global actions in Eclipse. * <p/> * This allows us to grab the standard labels and icons for the * global actions such as copy, cut, paste, delete and select-all. */ private void copyActionAttributes(Action action, ActionFactory factory) { IWorkbenchAction wa = factory.create(mEditorDelegate.getEditor().getEditorSite().getWorkbenchWindow()); action.setId(wa.getId()); action.setText(wa.getText()); action.setEnabled(wa.isEnabled()); action.setDescription(wa.getDescription()); action.setToolTipText(wa.getToolTipText()); action.setAccelerator(wa.getAccelerator()); action.setActionDefinitionId(wa.getActionDefinitionId()); action.setImageDescriptor(wa.getImageDescriptor()); action.setHoverImageDescriptor(wa.getHoverImageDescriptor()); action.setDisabledImageDescriptor(wa.getDisabledImageDescriptor()); action.setHelpListener(wa.getHelpListener()); } /** * Creates the context menu for the canvas. This is called once from the canvas' constructor. * <p/> * The menu has a static part with actions that are always available such as * copy, cut, paste and show in > explorer. This is created by * {@link #setupStaticMenuActions(IMenuManager)}. * <p/> * There's also a dynamic part that is populated by the rules of the * selected elements, created by {@link DynamicContextMenu}. */ @SuppressWarnings("unused") private void createContextMenu() { // This manager is the root of the context menu. mMenuManager = new MenuManager() { @Override public boolean isDynamic() { return true; } }; // Fill the menu manager with the static & dynamic actions setupStaticMenuActions(mMenuManager); new DynamicContextMenu(mEditorDelegate, this, mMenuManager); Menu menu = mMenuManager.createContextMenu(this); setMenu(menu); // Add listener to detect when the menu is about to be posted, such that // we can sync the selection. Without this, you can right click on something // in the canvas which is NOT selected, and the context menu will show items related // to the selection, NOT the item you clicked on!! addMenuDetectListener(new MenuDetectListener() { @Override public void menuDetected(MenuDetectEvent e) { mSelectionManager.menuClick(e); } }); } /** * Invoked by {@link #createContextMenu()} to create our *static* context menu once. * <p/> * The content of the menu itself does not change. However the state of the * various items is controlled by their associated actions. * <p/> * For cut/copy/paste/delete/select-all, we explicitly reuse the actions * created by {@link #setupGlobalActionHandlers()}, so this method must be * invoked after that one. */ private void setupStaticMenuActions(IMenuManager manager) { manager.removeAll(); manager.add(new SelectionManager.SelectionMenu(getGraphicalEditor())); manager.add(new Separator()); manager.add(mCutAction); manager.add(mCopyAction); manager.add(mPasteAction); manager.add(new Separator()); manager.add(mDeleteAction); manager.add(new Separator()); manager.add(new PlayAnimationMenu(this)); manager.add(new ExportScreenshotAction(this)); manager.add(new Separator()); // Group "Show Included In" and "Show In" together manager.add(new ShowWithinMenu(mEditorDelegate)); // Create a "Show In" sub-menu and automatically populate it using standard // actions contributed by the workbench. String showInLabel = IDEWorkbenchMessages.Workbench_showIn; MenuManager showInSubMenu = new MenuManager(showInLabel); showInSubMenu.add(ContributionItemFactory.VIEWS_SHOW_IN .create(mEditorDelegate.getEditor().getSite().getWorkbenchWindow())); manager.add(showInSubMenu); } /** * Deletes the selection. Equivalent to pressing the Delete key. */ void delete() { mDeleteAction.run(); } /** * Add new root in an existing empty XML layout. * <p/> * In case of error (unknown FQCN, document not empty), silently do nothing. * In case of success, the new element will have some default attributes set * (xmlns:android, layout_width and height). The edit is wrapped in a proper * undo. * <p/> * This is invoked by * {@link MoveGesture#drop(org.eclipse.swt.dnd.DropTargetEvent)}. * * @param root A non-null descriptor of the root element to create. */ void createDocumentRoot(final @NonNull SimpleElement root) { String rootFqcn = root.getFqcn(); // Need a valid empty document to create the new root final UiDocumentNode uiDoc = mEditorDelegate.getUiRootNode(); if (uiDoc == null || uiDoc.getUiChildren().size() > 0) { debugPrintf("Failed to create document root for %1$s: document is not empty", rootFqcn); return; } // Find the view descriptor matching our FQCN final ViewElementDescriptor viewDesc = mEditorDelegate.getFqcnViewDescriptor(rootFqcn); if (viewDesc == null) { // TODO this could happen if dropping a custom view not known in this project debugPrintf("Failed to add document root, unknown FQCN %1$s", rootFqcn); return; } // Get the last segment of the FQCN for the undo title String title = rootFqcn; int pos = title.lastIndexOf('.'); if (pos > 0 && pos < title.length() - 1) { title = title.substring(pos + 1); } title = String.format("Create root %1$s in document", title); mEditorDelegate.getEditor().wrapUndoEditXmlModel(title, new Runnable() { @Override public void run() { UiElementNode uiNew = uiDoc.appendNewUiChild(viewDesc); // A root node requires the Android XMLNS uiNew.setAttributeValue(SdkConstants.ANDROID_NS_NAME, SdkConstants.XMLNS_URI, SdkConstants.NS_RESOURCES, true /*override*/); IDragAttribute[] attributes = root.getAttributes(); if (attributes != null) { for (IDragAttribute attribute : attributes) { String uri = attribute.getUri(); String name = attribute.getName(); String value = attribute.getValue(); uiNew.setAttributeValue(name, uri, value, false /*override*/); } } // Adjust the attributes DescriptorsUtils.setDefaultLayoutAttributes(uiNew, false /*updateLayout*/); uiNew.createXmlNode(); } }); } /** * Returns the insets associated with views of the given fully qualified name, for the * current theme and screen type. * * @param fqcn the fully qualified name to the widget type * @return the insets, or null if unknown */ public Margins getInsets(String fqcn) { if (ViewMetadataRepository.INSETS_SUPPORTED) { ConfigurationChooser configComposite = getGraphicalEditor().getConfigurationChooser(); String theme = configComposite.getThemeName(); Density density = configComposite.getConfiguration().getDensity(); return ViewMetadataRepository.getInsets(fqcn, density, theme); } else { return null; } } private void debugPrintf(String message, Object... params) { if (DEBUG) { AdtPlugin.printToConsole("Canvas", String.format(message, params)); } } /** The associated editor has been deactivated */ public void deactivated() { // Force the tooltip to be hidden. If you switch from the layout editor // to a Java editor with the keyboard, the tooltip can stay open. if (mLintTooltipManager != null) { mLintTooltipManager.hide(); } } /** @see #setPreview(RenderPreview) */ private RenderPreview mPreview; /** * Sets the {@link RenderPreview} associated with the currently rendering * configuration. * <p> * A {@link RenderPreview} has various additional state beyond its rendering, * such as its display name (which can be edited by the user). When you click on * previews, the layout editor switches to show the given configuration preview. * The preview is then no longer shown in the list of previews and is instead rendered * in the main editor. However, when you then switch away to some other preview, we * want to be able to restore the preview with all its state. * * @param preview the preview associated with the current canvas */ public void setPreview(@Nullable RenderPreview preview) { mPreview = preview; } /** * Returns the {@link RenderPreview} associated with this layout canvas. * * @see #setPreview(RenderPreview) * @return the {@link RenderPreview} */ @Nullable public RenderPreview getPreview() { return mPreview; } /** Ensures that the configuration previews are up to date for this canvas */ public void syncPreviewMode() { if (mImageOverlay != null && mImageOverlay.getImage() != null && getGraphicalEditor().getConfigurationChooser().getResources() != null) { if (mPreviewManager.recomputePreviews(false)) { // Zoom when syncing modes mZoomFitNextImage = true; ensureZoomed(); } } } }