/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
*
* 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.uiautomator;
import com.android.uiautomator.actions.ExpandAllAction;
import com.android.uiautomator.actions.ToggleNafAction;
import com.android.uiautomator.tree.AttributePair;
import com.android.uiautomator.tree.BasicTreeNode;
import com.android.uiautomator.tree.BasicTreeNodeContentProvider;
import org.eclipse.jface.action.ToolBarManager;
import org.eclipse.jface.layout.TableColumnLayout;
import org.eclipse.jface.viewers.ArrayContentProvider;
import org.eclipse.jface.viewers.CellEditor;
import org.eclipse.jface.viewers.ColumnLabelProvider;
import org.eclipse.jface.viewers.ColumnWeightData;
import org.eclipse.jface.viewers.EditingSupport;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.LabelProvider;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.jface.viewers.TableViewer;
import org.eclipse.jface.viewers.TableViewerColumn;
import org.eclipse.jface.viewers.TextCellEditor;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.custom.StackLayout;
import org.eclipse.swt.events.MouseAdapter;
import org.eclipse.swt.events.MouseEvent;
import org.eclipse.swt.events.MouseMoveListener;
import org.eclipse.swt.events.PaintEvent;
import org.eclipse.swt.events.PaintListener;
import org.eclipse.swt.events.SelectionAdapter;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.ImageData;
import org.eclipse.swt.graphics.ImageLoader;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.graphics.Transform;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Canvas;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.FileDialog;
import org.eclipse.swt.widgets.Group;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.Tree;
import java.io.File;
public class UiAutomatorView extends Composite {
private static final int IMG_BORDER = 2;
// The screenshot area is made of a stack layout of two components: screenshot canvas and
// a "specify screenshot" button. If a screenshot is already available, then that is displayed
// on the canvas. If it is not availble, then the "specify screenshot" button is displayed.
private Composite mScreenshotComposite;
private StackLayout mStackLayout;
private Composite mSetScreenshotComposite;
private Canvas mScreenshotCanvas;
private TreeViewer mTreeViewer;
private TableViewer mTableViewer;
private float mScale = 1.0f;
private int mDx, mDy;
private UiAutomatorModel mModel;
private File mModelFile;
private Image mScreenshot;
public UiAutomatorView(Composite parent, int style) {
super(parent, SWT.NONE);
setLayout(new FillLayout());
SashForm baseSash = new SashForm(this, SWT.HORIZONTAL);
mScreenshotComposite = new Composite(baseSash, SWT.BORDER);
mStackLayout = new StackLayout();
mScreenshotComposite.setLayout(mStackLayout);
// draw the canvas with border, so the divider area for sash form can be highlighted
mScreenshotCanvas = new Canvas(mScreenshotComposite, SWT.BORDER);
mStackLayout.topControl = mScreenshotCanvas;
mScreenshotComposite.layout();
mScreenshotCanvas.addMouseListener(new MouseAdapter() {
@Override
public void mouseUp(MouseEvent e) {
if (mModel != null) {
mModel.toggleExploreMode();
redrawScreenshot();
}
}
});
mScreenshotCanvas.setBackground(
getShell().getDisplay().getSystemColor(SWT.COLOR_WIDGET_BACKGROUND));
mScreenshotCanvas.addPaintListener(new PaintListener() {
@Override
public void paintControl(PaintEvent e) {
if (mScreenshot != null) {
updateScreenshotTransformation();
// shifting the image here, so that there's a border around screen shot
// this makes highlighting red rectangles on the screen shot edges more visible
Transform t = new Transform(e.gc.getDevice());
t.translate(mDx, mDy);
t.scale(mScale, mScale);
e.gc.setTransform(t);
e.gc.drawImage(mScreenshot, 0, 0);
// this resets the transformation to identity transform, i.e. no change
// we don't use transformation here because it will cause the line pattern
// and line width of highlight rect to be scaled, causing to appear to be blurry
e.gc.setTransform(null);
if (mModel.shouldShowNafNodes()) {
// highlight the "Not Accessibility Friendly" nodes
e.gc.setForeground(e.gc.getDevice().getSystemColor(SWT.COLOR_YELLOW));
e.gc.setBackground(e.gc.getDevice().getSystemColor(SWT.COLOR_YELLOW));
for (Rectangle r : mModel.getNafNodes()) {
e.gc.setAlpha(50);
e.gc.fillRectangle(mDx + getScaledSize(r.x), mDy + getScaledSize(r.y),
getScaledSize(r.width), getScaledSize(r.height));
e.gc.setAlpha(255);
e.gc.setLineStyle(SWT.LINE_SOLID);
e.gc.setLineWidth(2);
e.gc.drawRectangle(mDx + getScaledSize(r.x), mDy + getScaledSize(r.y),
getScaledSize(r.width), getScaledSize(r.height));
}
}
// draw the mouseover rects
Rectangle rect = mModel.getCurrentDrawingRect();
if (rect != null) {
e.gc.setForeground(e.gc.getDevice().getSystemColor(SWT.COLOR_RED));
if (mModel.isExploreMode()) {
// when we highlight nodes dynamically on mouse move,
// use dashed borders
e.gc.setLineStyle(SWT.LINE_DASH);
e.gc.setLineWidth(1);
} else {
// when highlighting nodes on tree node selection,
// use solid borders
e.gc.setLineStyle(SWT.LINE_SOLID);
e.gc.setLineWidth(2);
}
e.gc.drawRectangle(mDx + getScaledSize(rect.x), mDy + getScaledSize(rect.y),
getScaledSize(rect.width), getScaledSize(rect.height));
}
}
}
});
mScreenshotCanvas.addMouseMoveListener(new MouseMoveListener() {
@Override
public void mouseMove(MouseEvent e) {
if (mModel != null && mModel.isExploreMode()) {
BasicTreeNode node = mModel.updateSelectionForCoordinates(
getInverseScaledSize(e.x - mDx),
getInverseScaledSize(e.y - mDy));
if (node != null) {
updateTreeSelection(node);
}
}
}
});
mSetScreenshotComposite = new Composite(mScreenshotComposite, SWT.NONE);
mSetScreenshotComposite.setLayout(new GridLayout());
final Button setScreenshotButton = new Button(mSetScreenshotComposite, SWT.PUSH);
setScreenshotButton.setText("Specify Screenshot...");
setScreenshotButton.addSelectionListener(new SelectionAdapter() {
@Override
public void widgetSelected(SelectionEvent arg0) {
FileDialog fd = new FileDialog(setScreenshotButton.getShell());
fd.setFilterExtensions(new String[] { "*.png" });
if (mModelFile != null) {
fd.setFilterPath(mModelFile.getParent());
}
String screenshotPath = fd.open();
if (screenshotPath == null) {
return;
}
ImageData[] data;
try {
data = new ImageLoader().load(screenshotPath);
} catch (Exception e) {
return;
}
// "data" is an array, probably used to handle images that has multiple frames
// i.e. gifs or icons, we just care if it has at least one here
if (data.length < 1) {
return;
}
mScreenshot = new Image(Display.getDefault(), data[0]);
redrawScreenshot();
}
});
// right sash is split into 2 parts: upper-right and lower-right
// both are composites with borders, so that the horizontal divider can be highlighted by
// the borders
SashForm rightSash = new SashForm(baseSash, SWT.VERTICAL);
// upper-right base contains the toolbar and the tree
Composite upperRightBase = new Composite(rightSash, SWT.BORDER);
upperRightBase.setLayout(new GridLayout(1, false));
ToolBarManager toolBarManager = new ToolBarManager(SWT.FLAT);
toolBarManager.add(new ExpandAllAction(this));
toolBarManager.add(new ToggleNafAction(this));
toolBarManager.createControl(upperRightBase);
mTreeViewer = new TreeViewer(upperRightBase, SWT.NONE);
mTreeViewer.setContentProvider(new BasicTreeNodeContentProvider());
// default LabelProvider uses toString() to generate text to display
mTreeViewer.setLabelProvider(new LabelProvider());
mTreeViewer.addSelectionChangedListener(new ISelectionChangedListener() {
@Override
public void selectionChanged(SelectionChangedEvent event) {
BasicTreeNode selectedNode = null;
if (event.getSelection() instanceof IStructuredSelection) {
IStructuredSelection selection = (IStructuredSelection) event.getSelection();
Object o = selection.getFirstElement();
if (o instanceof BasicTreeNode) {
selectedNode = (BasicTreeNode) o;
}
}
mModel.setSelectedNode(selectedNode);
redrawScreenshot();
if (selectedNode != null) {
loadAttributeTable();
}
}
});
Tree tree = mTreeViewer.getTree();
tree.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
// move focus so that it's not on tool bar (looks weird)
tree.setFocus();
// lower-right base contains the detail group
Composite lowerRightBase = new Composite(rightSash, SWT.BORDER);
lowerRightBase.setLayout(new FillLayout());
Group grpNodeDetail = new Group(lowerRightBase, SWT.NONE);
grpNodeDetail.setLayout(new FillLayout(SWT.HORIZONTAL));
grpNodeDetail.setText("Node Detail");
Composite tableContainer = new Composite(grpNodeDetail, SWT.NONE);
TableColumnLayout columnLayout = new TableColumnLayout();
tableContainer.setLayout(columnLayout);
mTableViewer = new TableViewer(tableContainer, SWT.NONE | SWT.FULL_SELECTION);
Table table = mTableViewer.getTable();
table.setLinesVisible(true);
// use ArrayContentProvider here, it assumes the input to the TableViewer
// is an array, where each element represents a row in the table
mTableViewer.setContentProvider(new ArrayContentProvider());
TableViewerColumn tableViewerColumnKey = new TableViewerColumn(mTableViewer, SWT.NONE);
TableColumn tblclmnKey = tableViewerColumnKey.getColumn();
tableViewerColumnKey.setLabelProvider(new ColumnLabelProvider() {
@Override
public String getText(Object element) {
if (element instanceof AttributePair) {
// first column, shows the attribute name
return ((AttributePair)element).key;
}
return super.getText(element);
}
});
columnLayout.setColumnData(tblclmnKey,
new ColumnWeightData(1, ColumnWeightData.MINIMUM_WIDTH, true));
TableViewerColumn tableViewerColumnValue = new TableViewerColumn(mTableViewer, SWT.NONE);
tableViewerColumnValue.setEditingSupport(new AttributeTableEditingSupport(mTableViewer));
TableColumn tblclmnValue = tableViewerColumnValue.getColumn();
columnLayout.setColumnData(tblclmnValue,
new ColumnWeightData(2, ColumnWeightData.MINIMUM_WIDTH, true));
tableViewerColumnValue.setLabelProvider(new ColumnLabelProvider() {
@Override
public String getText(Object element) {
if (element instanceof AttributePair) {
// second column, shows the attribute value
return ((AttributePair)element).value;
}
return super.getText(element);
}
});
// sets the ratio of the vertical split: left 5 vs right 3
baseSash.setWeights(new int[]{5, 3});
}
private int getScaledSize(int size) {
if (mScale == 1.0f) {
return size;
} else {
return new Double(Math.floor((size * mScale))).intValue();
}
}
private int getInverseScaledSize(int size) {
if (mScale == 1.0f) {
return size;
} else {
return new Double(Math.floor((size / mScale))).intValue();
}
}
private void updateScreenshotTransformation() {
Rectangle canvas = mScreenshotCanvas.getBounds();
Rectangle image = mScreenshot.getBounds();
float scaleX = (canvas.width - 2 * IMG_BORDER - 1) / (float)image.width;
float scaleY = (canvas.height - 2 * IMG_BORDER - 1) / (float)image.height;
// use the smaller scale here so that we can fit the entire screenshot
mScale = Math.min(scaleX, scaleY);
// calculate translation values to center the image on the canvas
mDx = (canvas.width - getScaledSize(image.width) - IMG_BORDER * 2) / 2 + IMG_BORDER;
mDy = (canvas.height - getScaledSize(image.height) - IMG_BORDER * 2) / 2 + IMG_BORDER;
}
private class AttributeTableEditingSupport extends EditingSupport {
private TableViewer mViewer;
public AttributeTableEditingSupport(TableViewer viewer) {
super(viewer);
mViewer = viewer;
}
@Override
protected boolean canEdit(Object arg0) {
return true;
}
@Override
protected CellEditor getCellEditor(Object arg0) {
return new TextCellEditor(mViewer.getTable());
}
@Override
protected Object getValue(Object o) {
return ((AttributePair)o).value;
}
@Override
protected void setValue(Object arg0, Object arg1) {
}
}
/**
* Causes a redraw of the canvas.
*
* The drawing code of canvas will handle highlighted nodes and etc based on data
* retrieved from Model
*/
public void redrawScreenshot() {
if (mScreenshot == null) {
mStackLayout.topControl = mSetScreenshotComposite;
} else {
mStackLayout.topControl = mScreenshotCanvas;
}
mScreenshotComposite.layout();
mScreenshotCanvas.redraw();
}
public void setInputHierarchy(Object input) {
mTreeViewer.setInput(input);
}
public void loadAttributeTable() {
// udpate the lower right corner table to show the attributes of the node
mTableViewer.setInput(mModel.getSelectedNode().getAttributesArray());
}
public void expandAll() {
mTreeViewer.expandAll();
}
public void updateTreeSelection(BasicTreeNode node) {
mTreeViewer.setSelection(new StructuredSelection(node), true);
}
public void setModel(UiAutomatorModel model, File modelBackingFile, Image screenshot) {
mModel = model;
mModelFile = modelBackingFile;
if (mScreenshot != null) {
mScreenshot.dispose();
}
mScreenshot = screenshot;
redrawScreenshot();
// load xml into tree
BasicTreeNode wrapper = new BasicTreeNode();
// putting another root node on top of existing root node
// because Tree seems to like to hide the root node
wrapper.addChild(mModel.getXmlRootNode());
setInputHierarchy(wrapper);
mTreeViewer.getTree().setFocus();
}
public boolean shouldShowNafNodes() {
return mModel != null ? mModel.shouldShowNafNodes() : false;
}
public void toggleShowNaf() {
if (mModel != null) {
mModel.toggleShowNaf();
}
}
}