/*
* 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();
}
}
}
}