Java tutorial
/* * Copyright (C) 2010 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 static com.android.SdkConstants.ANDROID_URI; import static com.android.SdkConstants.ATTR_COLUMN_COUNT; import static com.android.SdkConstants.ATTR_LAYOUT_COLUMN; import static com.android.SdkConstants.ATTR_LAYOUT_COLUMN_SPAN; import static com.android.SdkConstants.ATTR_LAYOUT_GRAVITY; import static com.android.SdkConstants.ATTR_LAYOUT_ROW; import static com.android.SdkConstants.ATTR_LAYOUT_ROW_SPAN; import static com.android.SdkConstants.ATTR_ROW_COUNT; import static com.android.SdkConstants.ATTR_SRC; import static com.android.SdkConstants.ATTR_TEXT; import static com.android.SdkConstants.AUTO_URI; import static com.android.SdkConstants.DRAWABLE_PREFIX; import static com.android.SdkConstants.GRID_LAYOUT; import static com.android.SdkConstants.LAYOUT_RESOURCE_PREFIX; import static com.android.SdkConstants.URI_PREFIX; import static org.eclipse.jface.viewers.StyledString.COUNTER_STYLER; import static org.eclipse.jface.viewers.StyledString.QUALIFIER_STYLER; import com.android.SdkConstants; import com.android.annotations.VisibleForTesting; import com.android.ide.common.api.INode; import com.android.ide.common.api.InsertType; import com.android.ide.common.layout.BaseLayoutRule; import com.android.ide.common.layout.GridLayoutRule; import com.android.ide.eclipse.adt.AdtPlugin; import com.android.ide.eclipse.adt.AdtUtils; import com.android.ide.eclipse.adt.internal.editors.IconFactory; 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.gle2.IncludeFinder.Reference; import com.android.ide.eclipse.adt.internal.editors.layout.gre.NodeProxy; import com.android.ide.eclipse.adt.internal.editors.layout.properties.PropertySheetPage; import com.android.ide.eclipse.adt.internal.editors.layout.uimodel.UiViewElementNode; import com.android.ide.eclipse.adt.internal.editors.manifest.ManifestInfo; import com.android.ide.eclipse.adt.internal.editors.uimodel.UiElementNode; import com.android.ide.eclipse.adt.internal.sdk.ProjectState; import com.android.ide.eclipse.adt.internal.sdk.Sdk; import com.android.utils.Pair; import org.eclipse.core.resources.IMarker; import org.eclipse.core.resources.IProject; 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.IMenuListener; import org.eclipse.jface.action.IMenuManager; import org.eclipse.jface.action.IToolBarManager; import org.eclipse.jface.action.MenuManager; import org.eclipse.jface.action.Separator; import org.eclipse.jface.preference.JFacePreferences; import org.eclipse.jface.viewers.DoubleClickEvent; import org.eclipse.jface.viewers.IDoubleClickListener; import org.eclipse.jface.viewers.IElementComparer; import org.eclipse.jface.viewers.ISelection; import org.eclipse.jface.viewers.ITreeContentProvider; import org.eclipse.jface.viewers.ITreeSelection; import org.eclipse.jface.viewers.SelectionChangedEvent; import org.eclipse.jface.viewers.StyledCellLabelProvider; import org.eclipse.jface.viewers.StyledString; import org.eclipse.jface.viewers.StyledString.Styler; import org.eclipse.jface.viewers.TreePath; import org.eclipse.jface.viewers.TreeSelection; import org.eclipse.jface.viewers.TreeViewer; import org.eclipse.jface.viewers.Viewer; import org.eclipse.jface.viewers.ViewerCell; import org.eclipse.swt.SWT; import org.eclipse.swt.dnd.DND; import org.eclipse.swt.dnd.Transfer; import org.eclipse.swt.events.DisposeEvent; import org.eclipse.swt.events.DisposeListener; import org.eclipse.swt.events.KeyEvent; import org.eclipse.swt.events.KeyListener; import org.eclipse.swt.events.MenuDetectEvent; import org.eclipse.swt.events.MenuDetectListener; import org.eclipse.swt.events.MouseEvent; import org.eclipse.swt.events.MouseListener; import org.eclipse.swt.graphics.Color; import org.eclipse.swt.graphics.Image; import org.eclipse.swt.graphics.Point; import org.eclipse.swt.graphics.Rectangle; import org.eclipse.swt.layout.FillLayout; import org.eclipse.swt.widgets.Composite; import org.eclipse.swt.widgets.Control; import org.eclipse.swt.widgets.Display; import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Label; import org.eclipse.swt.widgets.Listener; import org.eclipse.swt.widgets.Shell; import org.eclipse.swt.widgets.Text; import org.eclipse.swt.widgets.Tree; import org.eclipse.swt.widgets.TreeItem; import org.eclipse.ui.IActionBars; import org.eclipse.ui.IEditorPart; import org.eclipse.ui.INullSelectionListener; import org.eclipse.ui.IWorkbenchPart; import org.eclipse.ui.actions.ActionFactory; import org.eclipse.ui.views.contentoutline.ContentOutlinePage; import org.eclipse.wb.core.controls.SelfOrientingSashForm; import org.eclipse.wb.internal.core.editor.structure.IPage; import org.eclipse.wb.internal.core.editor.structure.PageSiteComposite; import org.w3c.dom.Element; import org.w3c.dom.Node; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; /** * An outline page for the layout canvas view. * <p/> * The page is created by {@link LayoutEditorDelegate#delegateGetAdapter(Class)}. This means * we have *one* instance of the outline page per open canvas editor. * <p/> * It sets itself as a listener on the site's selection service in order to be * notified of the canvas' selection changes. * The underlying page is also a selection provider (via IContentOutlinePage) * and as such it will broadcast selection changes to the site's selection service * (on which both the layout editor part and the property sheet page listen.) */ public class OutlinePage extends ContentOutlinePage implements INullSelectionListener, IPage { /** Label which separates outline text from additional attributes like text prefix or url */ private static final String LABEL_SEPARATOR = " - "; /** Max character count in labels, used for truncation */ private static final int LABEL_MAX_WIDTH = 50; /** * The graphical editor that created this outline. */ private final GraphicalEditorPart mGraphicalEditorPart; /** * RootWrapper is a workaround: we can't set the input of the TreeView to its root * element, so we introduce a fake parent. */ private final RootWrapper mRootWrapper = new RootWrapper(); /** * Menu manager for the context menu actions. * The actions delegate to the current GraphicalEditorPart. */ private MenuManager mMenuManager; private Composite mControl; private PropertySheetPage mPropertySheet; private PageSiteComposite mPropertySheetComposite; private boolean mShowPropertySheet; private boolean mShowHeader; private boolean mIgnoreSelection; private boolean mActive = true; /** Action to Select All in the tree */ private final Action mTreeSelectAllAction = new Action() { @Override public void run() { getTreeViewer().getTree().selectAll(); OutlinePage.this.fireSelectionChanged(getSelection()); } @Override public String getId() { return ActionFactory.SELECT_ALL.getId(); } }; /** Action for moving items up in the tree */ private Action mMoveUpAction = new Action("Move Up\t-", IconFactory.getInstance().getImageDescriptor("up")) { //$NON-NLS-2$ @Override public String getId() { return "adt.outline.moveup"; //$NON-NLS-1$ } @Override public boolean isEnabled() { return canMove(false); } @Override public void run() { move(false); } }; /** Action for moving items down in the tree */ private Action mMoveDownAction = new Action("Move Down\t+", IconFactory.getInstance().getImageDescriptor("down")) { //$NON-NLS-1$ @Override public String getId() { return "adt.outline.movedown"; //$NON-NLS-1$ } @Override public boolean isEnabled() { return canMove(true); } @Override public void run() { move(true); } }; /** * Creates a new {@link OutlinePage} associated with the given editor * * @param graphicalEditorPart the editor associated with this outline */ public OutlinePage(GraphicalEditorPart graphicalEditorPart) { super(); mGraphicalEditorPart = graphicalEditorPart; } @Override public Control getControl() { // We've injected some controls between the root of the outline page // and the tree control, so return the actual root (a sash form) rather // than the superclass' implementation which returns the tree. If we don't // do this, various checks in the outline page which checks that getControl().getParent() // is the outline window itself will ignore this page. return mControl; } void setActive(boolean active) { if (active != mActive) { mActive = active; // Outlines are by default active when they are created; this is intended // for deactivating a hidden outline and later reactivating it assert mControl != null; if (active) { getSite().getPage().addSelectionListener(this); setModel(mGraphicalEditorPart.getCanvasControl().getViewHierarchy().getRoot()); } else { getSite().getPage().removeSelectionListener(this); mRootWrapper.setRoot(null); if (mPropertySheet != null) { mPropertySheet.selectionChanged(null, TreeSelection.EMPTY); } } } } /** Refresh all the icon state */ public void refreshIcons() { TreeViewer treeViewer = getTreeViewer(); if (treeViewer != null) { Tree tree = treeViewer.getTree(); if (tree != null && !tree.isDisposed()) { treeViewer.refresh(); } } } /** * Set whether the outline should be shown in the header * * @param show whether a header should be shown */ public void setShowHeader(boolean show) { mShowHeader = show; } /** * Set whether the property sheet should be shown within this outline * * @param show whether the property sheet should show */ public void setShowPropertySheet(boolean show) { if (show != mShowPropertySheet) { mShowPropertySheet = show; if (mControl == null) { return; } if (show && mPropertySheet == null) { createPropertySheet(); } else if (!show) { mPropertySheetComposite.dispose(); mPropertySheetComposite = null; mPropertySheet.dispose(); mPropertySheet = null; } mControl.layout(); } } @Override public void createControl(Composite parent) { mControl = new SelfOrientingSashForm(parent, SWT.VERTICAL); if (mShowHeader) { PageSiteComposite mOutlineComposite = new PageSiteComposite(mControl, SWT.BORDER); mOutlineComposite.setTitleText("Outline"); mOutlineComposite.setTitleImage(IconFactory.getInstance().getIcon("components_view")); mOutlineComposite.setPage(new IPage() { @Override public void createControl(Composite outlineParent) { createOutline(outlineParent); } @Override public void dispose() { } @Override public Control getControl() { return getTreeViewer().getTree(); } @Override public void setToolBar(IToolBarManager toolBarManager) { makeContributions(null, toolBarManager, null); toolBarManager.update(false); } @Override public void setFocus() { getControl().setFocus(); } }); } else { createOutline(mControl); } if (mShowPropertySheet) { createPropertySheet(); } } private void createOutline(Composite parent) { if (AdtUtils.isEclipse4()) { // This is a workaround for the focus behavior in Eclipse 4 where // the framework ends up calling setFocus() on the first widget in the outline // AFTER a mouse click has been received. Specifically, if the user clicks in // the embedded property sheet to for example give a Text property editor focus, // then after the mouse click, the Outline window activation event is processed, // and this event causes setFocus() to be called first on the PageBookView (which // ends up calling setFocus on the first control, normally the TreeViewer), and // then on the Page itself. We're dealing with the page setFocus() in the override // of that method in the class, such that it does nothing. // However, we have to also disable the setFocus on the first control in the // outline page. To deal with that, we create our *own* first control in the // outline, and make its setFocus() a no-op. We also make it invisible, since we // don't actually want anything but the tree viewer showing in the outline. Text text = new Text(parent, SWT.NONE) { @Override public boolean setFocus() { // Focus no-op return true; } @Override protected void checkSubclass() { // Disable the check that prevents subclassing of SWT components } }; text.setVisible(false); } super.createControl(parent); TreeViewer tv = getTreeViewer(); tv.setAutoExpandLevel(2); tv.setContentProvider(new ContentProvider()); tv.setLabelProvider(new LabelProvider()); tv.setInput(mRootWrapper); tv.expandToLevel(mRootWrapper.getRoot(), 2); int supportedOperations = DND.DROP_COPY | DND.DROP_MOVE; Transfer[] transfers = new Transfer[] { SimpleXmlTransfer.getInstance() }; tv.addDropSupport(supportedOperations, transfers, new OutlineDropListener(this, tv)); tv.addDragSupport(supportedOperations, transfers, new OutlineDragListener(this, tv)); // The tree viewer will hold CanvasViewInfo instances, however these // change each time the canvas is reloaded. OTOH layoutlib gives us // constant UiView keys which we can use to perform tree item comparisons. tv.setComparer(new IElementComparer() { @Override public int hashCode(Object element) { if (element instanceof CanvasViewInfo) { UiViewElementNode key = ((CanvasViewInfo) element).getUiViewNode(); if (key != null) { return key.hashCode(); } } if (element != null) { return element.hashCode(); } return 0; } @Override public boolean equals(Object a, Object b) { if (a instanceof CanvasViewInfo && b instanceof CanvasViewInfo) { UiViewElementNode keyA = ((CanvasViewInfo) a).getUiViewNode(); UiViewElementNode keyB = ((CanvasViewInfo) b).getUiViewNode(); if (keyA != null) { return keyA.equals(keyB); } } if (a != null) { return a.equals(b); } return false; } }); tv.addDoubleClickListener(new IDoubleClickListener() { @Override public void doubleClick(DoubleClickEvent event) { // This used to open the property view, but now that properties are docked // let's use it for something else -- such as showing the editor source /* // Front properties panel; its selection is already linked IWorkbenchPage page = getSite().getPage(); try { page.showView(IPageLayout.ID_PROP_SHEET, null, IWorkbenchPage.VIEW_ACTIVATE); } catch (PartInitException e) { AdtPlugin.log(e, "Could not activate property sheet"); } */ TreeItem[] selection = getTreeViewer().getTree().getSelection(); if (selection.length > 0) { CanvasViewInfo vi = getViewInfo(selection[0].getData()); if (vi != null) { LayoutCanvas canvas = mGraphicalEditorPart.getCanvasControl(); canvas.show(vi); } } } }); setupContextMenu(); // Listen to selection changes from the layout editor getSite().getPage().addSelectionListener(this); getControl().addDisposeListener(new DisposeListener() { @Override public void widgetDisposed(DisposeEvent e) { dispose(); } }); Tree tree = tv.getTree(); tree.addKeyListener(new KeyListener() { @Override public void keyPressed(KeyEvent e) { if (e.character == '-') { if (mMoveUpAction.isEnabled()) { mMoveUpAction.run(); } } else if (e.character == '+') { if (mMoveDownAction.isEnabled()) { mMoveDownAction.run(); } } } @Override public void keyReleased(KeyEvent e) { } }); setupTooltip(); } /** * This flag is true when the mouse button is being pressed somewhere inside * the property sheet */ private boolean mPressInPropSheet; private void createPropertySheet() { mPropertySheetComposite = new PageSiteComposite(mControl, SWT.BORDER); mPropertySheetComposite.setTitleText("Properties"); mPropertySheetComposite.setTitleImage(IconFactory.getInstance().getIcon("properties_view")); mPropertySheet = new PropertySheetPage(mGraphicalEditorPart); mPropertySheetComposite.setPage(mPropertySheet); if (AdtUtils.isEclipse4()) { mPropertySheet.getControl().addMouseListener(new MouseListener() { @Override public void mouseDown(MouseEvent e) { mPressInPropSheet = true; } @Override public void mouseUp(MouseEvent e) { mPressInPropSheet = false; } @Override public void mouseDoubleClick(MouseEvent e) { } }); } } @Override public void setFocus() { // Only call setFocus on the tree viewer if the mouse click isn't in the property // sheet area if (!mPressInPropSheet) { super.setFocus(); } } @Override public void dispose() { mRootWrapper.setRoot(null); getSite().getPage().removeSelectionListener(this); super.dispose(); if (mPropertySheet != null) { mPropertySheet.dispose(); mPropertySheet = null; } } /** * Invoked by {@link LayoutCanvas} to set the model (a.k.a. the root view info). * * @param rootViewInfo The root of the view info hierarchy. Can be null. */ public void setModel(CanvasViewInfo rootViewInfo) { if (!mActive) { return; } mRootWrapper.setRoot(rootViewInfo); TreeViewer tv = getTreeViewer(); if (tv != null && !tv.getTree().isDisposed()) { Object[] expanded = tv.getExpandedElements(); tv.refresh(); tv.setExpandedElements(expanded); // Ensure that the root is expanded tv.expandToLevel(rootViewInfo, 2); } } /** * Returns the current tree viewer selection. Shouldn't be null, * although it can be {@link TreeSelection#EMPTY}. */ @Override public ISelection getSelection() { return super.getSelection(); } /** * Sets the outline selection. * * @param selection Only {@link ITreeSelection} will be used, otherwise the * selection will be cleared (including a null selection). */ @Override public void setSelection(ISelection selection) { // TreeViewer should be able to deal with a null selection, but let's make it safe if (selection == null) { selection = TreeSelection.EMPTY; } if (selection.equals(TreeSelection.EMPTY)) { return; } super.setSelection(selection); TreeViewer tv = getTreeViewer(); if (tv == null || !(selection instanceof ITreeSelection) || selection.isEmpty()) { return; } // auto-reveal the selection ITreeSelection treeSel = (ITreeSelection) selection; for (TreePath p : treeSel.getPaths()) { tv.expandToLevel(p, 1); } } @Override protected void fireSelectionChanged(ISelection selection) { super.fireSelectionChanged(selection); if (mPropertySheet != null && !mIgnoreSelection) { mPropertySheet.selectionChanged(null, selection); } } /** * Listens to a workbench selection. * Only listen on selection coming from {@link LayoutEditorDelegate}, which avoid * picking up our own selections. */ @Override public void selectionChanged(IWorkbenchPart part, ISelection selection) { if (mIgnoreSelection) { return; } if (part instanceof IEditorPart) { LayoutEditorDelegate delegate = LayoutEditorDelegate.fromEditor((IEditorPart) part); if (delegate != null) { try { mIgnoreSelection = true; setSelection(selection); if (mPropertySheet != null) { mPropertySheet.selectionChanged(part, selection); } } finally { mIgnoreSelection = false; } } } } @Override public void selectionChanged(SelectionChangedEvent event) { if (!mIgnoreSelection) { super.selectionChanged(event); } } // ---- /** * In theory, the root of the model should be the input of the {@link TreeViewer}, * which would be the root {@link CanvasViewInfo}. * That means in theory {@link ContentProvider#getElements(Object)} should return * its own input as the single root node. * <p/> * However as described in JFace Bug 9262, this case is not properly handled by * a {@link TreeViewer} and leads to an infinite recursion in the tree viewer. * See https://bugs.eclipse.org/bugs/show_bug.cgi?id=9262 * <p/> * The solution is to wrap the tree viewer input in a dummy root node that acts * as a parent. This class does just that. */ private static class RootWrapper { private CanvasViewInfo mRoot; public void setRoot(CanvasViewInfo root) { mRoot = root; } public CanvasViewInfo getRoot() { return mRoot; } } /** Return the {@link CanvasViewInfo} associated with the given TreeItem's data field */ /* package */ static CanvasViewInfo getViewInfo(Object viewData) { if (viewData instanceof RootWrapper) { return ((RootWrapper) viewData).getRoot(); } if (viewData instanceof CanvasViewInfo) { return (CanvasViewInfo) viewData; } return null; } // --- Content and Label Providers --- /** * Content provider for the Outline model. * Objects are going to be {@link CanvasViewInfo}. */ private static class ContentProvider implements ITreeContentProvider { @Override public Object[] getChildren(Object element) { if (element instanceof RootWrapper) { CanvasViewInfo root = ((RootWrapper) element).getRoot(); if (root != null) { return new Object[] { root }; } } if (element instanceof CanvasViewInfo) { List<CanvasViewInfo> children = ((CanvasViewInfo) element).getUniqueChildren(); if (children != null) { return children.toArray(); } } return new Object[0]; } @Override public Object getParent(Object element) { if (element instanceof CanvasViewInfo) { return ((CanvasViewInfo) element).getParent(); } return null; } @Override public boolean hasChildren(Object element) { if (element instanceof CanvasViewInfo) { List<CanvasViewInfo> children = ((CanvasViewInfo) element).getChildren(); if (children != null) { return children.size() > 0; } } return false; } /** * Returns the root element. * Semantically, the root element is the single top-level XML element of the XML layout. */ @Override public Object[] getElements(Object inputElement) { return getChildren(inputElement); } @Override public void dispose() { // pass } @Override public void inputChanged(Viewer viewer, Object oldInput, Object newInput) { // pass } } /** * Label provider for the Outline model. * Objects are going to be {@link CanvasViewInfo}. */ private class LabelProvider extends StyledCellLabelProvider { /** * Returns the element's logo with a fallback on the android logo. * * @param element the tree element * @return the image to be used as a logo */ public Image getImage(Object element) { if (element instanceof CanvasViewInfo) { element = ((CanvasViewInfo) element).getUiViewNode(); } if (element instanceof UiViewElementNode) { UiViewElementNode v = (UiViewElementNode) element; return v.getIcon(); } return AdtPlugin.getAndroidLogo(); } /** * Uses {@link UiElementNode#getStyledDescription} for the label for this tree item. */ @Override public void update(ViewerCell cell) { Object element = cell.getElement(); StyledString styledString = null; CanvasViewInfo vi = null; if (element instanceof CanvasViewInfo) { vi = (CanvasViewInfo) element; element = vi.getUiViewNode(); } Image image = getImage(element); if (element instanceof UiElementNode) { UiElementNode node = (UiElementNode) element; styledString = node.getStyledDescription(); Node xmlNode = node.getXmlNode(); if (xmlNode instanceof Element) { Element e = (Element) xmlNode; // Temporary diagnostics code when developing GridLayout if (GridLayoutRule.sDebugGridLayout) { String namespace; if (e.getNodeName().equals(GRID_LAYOUT) || e.getParentNode() != null && e.getParentNode().getNodeName().equals(GRID_LAYOUT)) { namespace = ANDROID_URI; } else { // Else: probably a v7 gridlayout IProject project = mGraphicalEditorPart.getProject(); ProjectState projectState = Sdk.getProjectState(project); if (projectState != null && projectState.isLibrary()) { namespace = AUTO_URI; } else { ManifestInfo info = ManifestInfo.get(project); namespace = URI_PREFIX + info.getPackage(); } } if (e.getNodeName() != null && e.getNodeName().endsWith(GRID_LAYOUT)) { // Attach rowCount/columnCount info String rowCount = e.getAttributeNS(namespace, ATTR_ROW_COUNT); if (rowCount.length() == 0) { rowCount = "?"; } String columnCount = e.getAttributeNS(namespace, ATTR_COLUMN_COUNT); if (columnCount.length() == 0) { columnCount = "?"; } styledString.append(" - columnCount=", QUALIFIER_STYLER); styledString.append(columnCount, QUALIFIER_STYLER); styledString.append(", rowCount=", QUALIFIER_STYLER); styledString.append(rowCount, QUALIFIER_STYLER); } else if (e.getParentNode() != null && e.getParentNode().getNodeName() != null && e.getParentNode().getNodeName().endsWith(GRID_LAYOUT)) { // Attach row/column info String row = e.getAttributeNS(namespace, ATTR_LAYOUT_ROW); if (row.length() == 0) { row = "?"; } Styler colStyle = QUALIFIER_STYLER; String column = e.getAttributeNS(namespace, ATTR_LAYOUT_COLUMN); if (column.length() == 0) { column = "?"; } else { String colCount = ((Element) e.getParentNode()).getAttributeNS(namespace, ATTR_COLUMN_COUNT); if (colCount.length() > 0 && Integer.parseInt(colCount) <= Integer.parseInt(column)) { colStyle = StyledString.createColorRegistryStyler(JFacePreferences.ERROR_COLOR, null); } } String rowSpan = e.getAttributeNS(namespace, ATTR_LAYOUT_ROW_SPAN); String columnSpan = e.getAttributeNS(namespace, ATTR_LAYOUT_COLUMN_SPAN); if (rowSpan.length() == 0) { rowSpan = "1"; } if (columnSpan.length() == 0) { columnSpan = "1"; } styledString.append(" - cell (row=", QUALIFIER_STYLER); styledString.append(row, QUALIFIER_STYLER); styledString.append(',', QUALIFIER_STYLER); styledString.append("col=", colStyle); styledString.append(column, colStyle); styledString.append(')', colStyle); styledString.append(", span=(", QUALIFIER_STYLER); styledString.append(columnSpan, QUALIFIER_STYLER); styledString.append(',', QUALIFIER_STYLER); styledString.append(rowSpan, QUALIFIER_STYLER); styledString.append(')', QUALIFIER_STYLER); String gravity = e.getAttributeNS(namespace, ATTR_LAYOUT_GRAVITY); if (gravity != null && gravity.length() > 0) { styledString.append(" : ", COUNTER_STYLER); styledString.append(gravity, COUNTER_STYLER); } } } if (e.hasAttributeNS(ANDROID_URI, ATTR_TEXT)) { // Show the text attribute String text = e.getAttributeNS(ANDROID_URI, ATTR_TEXT); if (text != null && text.length() > 0 && !text.contains(node.getDescriptor().getUiName())) { if (text.charAt(0) == '@') { String resolved = mGraphicalEditorPart.findString(text); if (resolved != null) { text = resolved; } } if (styledString.length() < LABEL_MAX_WIDTH - LABEL_SEPARATOR.length() - 2) { styledString.append(LABEL_SEPARATOR, QUALIFIER_STYLER); styledString.append('"', QUALIFIER_STYLER); styledString.append(truncate(text, styledString), QUALIFIER_STYLER); styledString.append('"', QUALIFIER_STYLER); } } } else if (e.hasAttributeNS(ANDROID_URI, ATTR_SRC)) { // Show ImageView source attributes etc String src = e.getAttributeNS(ANDROID_URI, ATTR_SRC); if (src != null && src.length() > 0) { if (src.startsWith(DRAWABLE_PREFIX)) { src = src.substring(DRAWABLE_PREFIX.length()); } styledString.append(LABEL_SEPARATOR, QUALIFIER_STYLER); styledString.append(truncate(src, styledString), QUALIFIER_STYLER); } } else if (e.getTagName().equals(SdkConstants.VIEW_INCLUDE)) { // Show the include reference. // Note: the layout attribute is NOT in the Android namespace String src = e.getAttribute(SdkConstants.ATTR_LAYOUT); if (src != null && src.length() > 0) { if (src.startsWith(LAYOUT_RESOURCE_PREFIX)) { src = src.substring(LAYOUT_RESOURCE_PREFIX.length()); } styledString.append(LABEL_SEPARATOR, QUALIFIER_STYLER); styledString.append(truncate(src, styledString), QUALIFIER_STYLER); } } } } else if (element == null && vi != null) { // It's an inclusion-context: display it Reference includedWithin = mGraphicalEditorPart.getIncludedWithin(); if (includedWithin != null) { styledString = new StyledString(); styledString.append(includedWithin.getDisplayName(), QUALIFIER_STYLER); image = IconFactory.getInstance().getIcon(SdkConstants.VIEW_INCLUDE); } } if (styledString == null) { styledString = new StyledString(); styledString.append(element == null ? "(null)" : element.toString()); } cell.setText(styledString.toString()); cell.setStyleRanges(styledString.getStyleRanges()); cell.setImage(image); super.update(cell); } @Override public boolean isLabelProperty(Object element, String property) { return super.isLabelProperty(element, property); } } // --- Context Menu --- /** * This viewer uses its own actions that delegate to the ones given * by the {@link LayoutCanvas}. All the processing is actually handled * directly by the canvas and this viewer only gets refreshed as a * consequence of the canvas changing the XML model. */ private void setupContextMenu() { mMenuManager = new MenuManager(); mMenuManager.removeAll(); mMenuManager.add(mMoveUpAction); mMenuManager.add(mMoveDownAction); mMenuManager.add(new Separator()); mMenuManager.add(new SelectionManager.SelectionMenu(mGraphicalEditorPart)); mMenuManager.add(new Separator()); final String prefix = LayoutCanvas.PREFIX_CANVAS_ACTION; mMenuManager.add(new DelegateAction(prefix + ActionFactory.CUT.getId())); mMenuManager.add(new DelegateAction(prefix + ActionFactory.COPY.getId())); mMenuManager.add(new DelegateAction(prefix + ActionFactory.PASTE.getId())); mMenuManager.add(new Separator()); mMenuManager.add(new DelegateAction(prefix + ActionFactory.DELETE.getId())); mMenuManager.addMenuListener(new IMenuListener() { @Override public void menuAboutToShow(IMenuManager manager) { // Update all actions to match their LayoutCanvas counterparts for (IContributionItem contrib : manager.getItems()) { if (contrib instanceof ActionContributionItem) { IAction action = ((ActionContributionItem) contrib).getAction(); if (action instanceof DelegateAction) { ((DelegateAction) action).updateFromEditorPart(mGraphicalEditorPart); } } } } }); new DynamicContextMenu(mGraphicalEditorPart.getEditorDelegate(), mGraphicalEditorPart.getCanvasControl(), mMenuManager); getTreeViewer().getTree().setMenu(mMenuManager.createContextMenu(getControl())); // Update Move Up/Move Down state only when the menu is opened getTreeViewer().getTree().addMenuDetectListener(new MenuDetectListener() { @Override public void menuDetected(MenuDetectEvent e) { mMenuManager.update(IAction.ENABLED); } }); } /** * An action that delegates its properties and behavior to a target action. * The target action can be null or it can change overtime, typically as the * layout canvas' editor part is activated or closed. */ private static class DelegateAction extends Action { private IAction mTargetAction; private final String mCanvasActionId; public DelegateAction(String canvasActionId) { super(canvasActionId); setId(canvasActionId); mCanvasActionId = canvasActionId; } // --- Methods form IAction --- /** Returns the target action's {@link #isEnabled()} if defined, or false. */ @Override public boolean isEnabled() { return mTargetAction == null ? false : mTargetAction.isEnabled(); } /** Returns the target action's {@link #isChecked()} if defined, or false. */ @Override public boolean isChecked() { return mTargetAction == null ? false : mTargetAction.isChecked(); } /** Returns the target action's {@link #isHandled()} if defined, or false. */ @Override public boolean isHandled() { return mTargetAction == null ? false : mTargetAction.isHandled(); } /** Runs the target action if defined. */ @Override public void run() { if (mTargetAction != null) { mTargetAction.run(); } super.run(); } /** * Updates this action to delegate to its counterpart in the given editor part * * @param editorPart The editor being updated */ public void updateFromEditorPart(GraphicalEditorPart editorPart) { LayoutCanvas canvas = editorPart == null ? null : editorPart.getCanvasControl(); if (canvas == null) { mTargetAction = null; } else { mTargetAction = canvas.getAction(mCanvasActionId); } if (mTargetAction != null) { setText(mTargetAction.getText()); setId(mTargetAction.getId()); setDescription(mTargetAction.getDescription()); setImageDescriptor(mTargetAction.getImageDescriptor()); setHoverImageDescriptor(mTargetAction.getHoverImageDescriptor()); setDisabledImageDescriptor(mTargetAction.getDisabledImageDescriptor()); setToolTipText(mTargetAction.getToolTipText()); setActionDefinitionId(mTargetAction.getActionDefinitionId()); setHelpListener(mTargetAction.getHelpListener()); setAccelerator(mTargetAction.getAccelerator()); setChecked(mTargetAction.isChecked()); setEnabled(mTargetAction.isEnabled()); } else { setEnabled(false); } } } /** Returns the associated editor with this outline */ /* package */GraphicalEditorPart getEditor() { return mGraphicalEditorPart; } @Override public void setActionBars(IActionBars actionBars) { super.setActionBars(actionBars); // Map Outline actions to canvas actions such that they share Undo context etc LayoutCanvas canvas = mGraphicalEditorPart.getCanvasControl(); canvas.updateGlobalActions(actionBars); // Special handling for Select All since it's different than the canvas (will // include selecting the root etc) actionBars.setGlobalActionHandler(mTreeSelectAllAction.getId(), mTreeSelectAllAction); actionBars.updateActionBars(); } // ---- Move Up/Down Support ---- /** Returns true if the current selected item can be moved */ private boolean canMove(boolean forward) { CanvasViewInfo viewInfo = getSingleSelectedItem(); if (viewInfo != null) { UiViewElementNode node = viewInfo.getUiViewNode(); if (forward) { return findNext(node) != null; } else { return findPrevious(node) != null; } } return false; } /** Moves the current selected item down (forward) or up (not forward) */ private void move(boolean forward) { CanvasViewInfo viewInfo = getSingleSelectedItem(); if (viewInfo != null) { final Pair<UiViewElementNode, Integer> target; UiViewElementNode selected = viewInfo.getUiViewNode(); if (forward) { target = findNext(selected); } else { target = findPrevious(selected); } if (target != null) { final LayoutCanvas canvas = mGraphicalEditorPart.getCanvasControl(); final SelectionManager selectionManager = canvas.getSelectionManager(); final ArrayList<SelectionItem> dragSelection = new ArrayList<SelectionItem>(); dragSelection.add(selectionManager.createSelection(viewInfo)); SelectionManager.sanitize(dragSelection); if (!dragSelection.isEmpty()) { final SimpleElement[] elements = SelectionItem.getAsElements(dragSelection); UiViewElementNode parentNode = target.getFirst(); final NodeProxy targetNode = canvas.getNodeFactory().create(parentNode); // Record children of the target right before the drop (such that we // can find out after the drop which exact children were inserted) Set<INode> children = new HashSet<INode>(); for (INode node : targetNode.getChildren()) { children.add(node); } String label = MoveGesture.computeUndoLabel(targetNode, elements, DND.DROP_MOVE); canvas.getEditorDelegate().getEditor().wrapUndoEditXmlModel(label, new Runnable() { @Override public void run() { InsertType insertType = InsertType.MOVE_INTO; if (dragSelection.get(0).getNode().getParent() == targetNode) { insertType = InsertType.MOVE_WITHIN; } canvas.getRulesEngine().setInsertType(insertType); int index = target.getSecond(); BaseLayoutRule.insertAt(targetNode, elements, false, index); targetNode.applyPendingChanges(); canvas.getClipboardSupport().deleteSelection("Remove", dragSelection); } }); // Now find out which nodes were added, and look up their // corresponding CanvasViewInfos final List<INode> added = new ArrayList<INode>(); for (INode node : targetNode.getChildren()) { if (!children.contains(node)) { added.add(node); } } selectionManager.setOutlineSelection(added); } } } } /** * Returns the {@link CanvasViewInfo} for the currently selected item, or null if * there are no or multiple selected items * * @return the current selected item if there is exactly one item selected */ private CanvasViewInfo getSingleSelectedItem() { TreeItem[] selection = getTreeViewer().getTree().getSelection(); if (selection.length == 1) { return getViewInfo(selection[0].getData()); } return null; } /** Returns the pair [parent,index] of the next node (when iterating forward) */ @VisibleForTesting /* package */ static Pair<UiViewElementNode, Integer> findNext(UiViewElementNode node) { UiElementNode parent = node.getUiParent(); if (parent == null) { return null; } UiElementNode next = node.getUiNextSibling(); if (next != null) { if (DescriptorsUtils.canInsertChildren(next.getDescriptor(), null)) { return getFirstPosition(next); } else { return getPositionAfter(next); } } next = parent.getUiNextSibling(); if (next != null) { return getPositionBefore(next); } else { UiElementNode grandParent = parent.getUiParent(); if (grandParent != null) { return getLastPosition(grandParent); } } return null; } /** Returns the pair [parent,index] of the previous node (when iterating backward) */ @VisibleForTesting /* package */ static Pair<UiViewElementNode, Integer> findPrevious(UiViewElementNode node) { UiElementNode prev = node.getUiPreviousSibling(); if (prev != null) { UiElementNode curr = prev; while (true) { List<UiElementNode> children = curr.getUiChildren(); if (children.size() > 0) { curr = children.get(children.size() - 1); continue; } if (DescriptorsUtils.canInsertChildren(curr.getDescriptor(), null)) { return getFirstPosition(curr); } else { if (curr == prev) { return getPositionBefore(curr); } else { return getPositionAfter(curr); } } } } return getPositionBefore(node.getUiParent()); } /** Returns the pair [parent,index] of the position immediately before the given node */ private static Pair<UiViewElementNode, Integer> getPositionBefore(UiElementNode node) { if (node != null) { UiElementNode parent = node.getUiParent(); if (parent != null && parent instanceof UiViewElementNode) { return Pair.of((UiViewElementNode) parent, node.getUiSiblingIndex()); } } return null; } /** Returns the pair [parent,index] of the position immediately following the given node */ private static Pair<UiViewElementNode, Integer> getPositionAfter(UiElementNode node) { if (node != null) { UiElementNode parent = node.getUiParent(); if (parent != null && parent instanceof UiViewElementNode) { return Pair.of((UiViewElementNode) parent, node.getUiSiblingIndex() + 1); } } return null; } /** Returns the pair [parent,index] of the first position inside the given parent */ private static Pair<UiViewElementNode, Integer> getFirstPosition(UiElementNode parent) { if (parent != null && parent instanceof UiViewElementNode) { return Pair.of((UiViewElementNode) parent, 0); } return null; } /** * Returns the pair [parent,index] of the last position after the given node's * children */ private static Pair<UiViewElementNode, Integer> getLastPosition(UiElementNode parent) { if (parent != null && parent instanceof UiViewElementNode) { return Pair.of((UiViewElementNode) parent, parent.getUiChildren().size()); } return null; } /** * Truncates the given text such that it will fit into the given {@link StyledString} * up to a maximum length of {@link #LABEL_MAX_WIDTH}. * * @param text the text to truncate * @param string the existing string to be appended to * @return the truncated string */ private static String truncate(String text, StyledString string) { int existingLength = string.length(); if (text.length() + existingLength > LABEL_MAX_WIDTH) { int truncatedLength = LABEL_MAX_WIDTH - existingLength - 3; if (truncatedLength > 0) { return String.format("%1$s...", text.substring(0, truncatedLength)); } else { return ""; //$NON-NLS-1$ } } return text; } @Override public void setToolBar(IToolBarManager toolBarManager) { makeContributions(null, toolBarManager, null); toolBarManager.update(false); } /** * Sets up a custom tooltip when hovering over tree items. It currently displays the error * message for the lint warning associated with each node, if any (and only if the hover * is over the icon portion). */ private void setupTooltip() { final Tree tree = getTreeViewer().getTree(); // This is based on SWT Snippet 125 final Listener listener = new Listener() { Shell mTip = null; Label mLabel = null; @Override public void handleEvent(Event event) { switch (event.type) { case SWT.Dispose: case SWT.KeyDown: case SWT.MouseExit: case SWT.MouseDown: case SWT.MouseMove: if (mTip != null) { mTip.dispose(); mTip = null; mLabel = null; } break; case SWT.MouseHover: if (mTip != null) { mTip.dispose(); mTip = null; mLabel = null; } String tooltip = null; TreeItem item = tree.getItem(new Point(event.x, event.y)); if (item != null) { Rectangle rect = item.getBounds(0); if (event.x - rect.x > 16) { // 16: Standard width of our outline icons return; } Object data = item.getData(); if (data != null && data instanceof CanvasViewInfo) { LayoutEditorDelegate editor = mGraphicalEditorPart.getEditorDelegate(); CanvasViewInfo vi = (CanvasViewInfo) data; IMarker marker = editor.getIssueForNode(vi.getUiViewNode()); if (marker != null) { tooltip = marker.getAttribute(IMarker.MESSAGE, null); } } if (tooltip != null) { Shell shell = tree.getShell(); Display display = tree.getDisplay(); Color fg = display.getSystemColor(SWT.COLOR_INFO_FOREGROUND); Color bg = display.getSystemColor(SWT.COLOR_INFO_BACKGROUND); mTip = new Shell(shell, SWT.ON_TOP | SWT.NO_FOCUS | SWT.TOOL); mTip.setBackground(bg); FillLayout layout = new FillLayout(); layout.marginWidth = 1; layout.marginHeight = 1; mTip.setLayout(layout); mLabel = new Label(mTip, SWT.WRAP); mLabel.setForeground(fg); mLabel.setBackground(bg); mLabel.setText(tooltip); mLabel.addListener(SWT.MouseExit, this); mLabel.addListener(SWT.MouseDown, this); Point pt = tree.toDisplay(rect.x, rect.y + rect.height); Rectangle displayBounds = display.getBounds(); // -10: Don't extend -all- the way to the edge of the screen // which would make it look like it has been cropped int availableWidth = displayBounds.x + displayBounds.width - pt.x - 10; if (availableWidth < 80) { availableWidth = 80; } Point size = mTip.computeSize(SWT.DEFAULT, SWT.DEFAULT); if (size.x > availableWidth) { size = mTip.computeSize(availableWidth, SWT.DEFAULT); } mTip.setBounds(pt.x, pt.y, size.x, size.y); mTip.setVisible(true); } } } } }; tree.addListener(SWT.Dispose, listener); tree.addListener(SWT.KeyDown, listener); tree.addListener(SWT.MouseMove, listener); tree.addListener(SWT.MouseHover, listener); } }