| /* |
| * 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-1$ |
| |
| @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); |
| } |
| } |
