--- /dev/null
+/*
+ * Copyright (C) 2006 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.traceview;
+
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.regex.Pattern;
+
+import org.eclipse.jface.viewers.IColorProvider;
+import org.eclipse.jface.viewers.ITableLabelProvider;
+import org.eclipse.jface.viewers.ITreeContentProvider;
+import org.eclipse.jface.viewers.LabelProvider;
+import org.eclipse.jface.viewers.TreeViewer;
+import org.eclipse.jface.viewers.Viewer;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.events.SelectionAdapter;
+import org.eclipse.swt.events.SelectionEvent;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.Image;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Tree;
+import org.eclipse.swt.widgets.TreeColumn;
+import org.eclipse.swt.widgets.TreeItem;
+
+class ProfileProvider implements ITreeContentProvider {
+
+ private MethodData[] mRoots;
+ private SelectionAdapter mListener;
+ private TreeViewer mTreeViewer;
+ private TraceReader mReader;
+ private Image mSortUp;
+ private Image mSortDown;
+ private String mColumnNames[] = { "Name", "Incl %", "Inclusive", "Excl %",
+ "Exclusive", "Calls+Recur\nCalls/Total", "Time/Call" };
+ private int mColumnWidths[] = { 370, 70, 70, 70, 70, 90, 70 };
+ private int mColumnAlignments[] = { SWT.LEFT, SWT.RIGHT, SWT.RIGHT,
+ SWT.RIGHT, SWT.RIGHT, SWT.CENTER, SWT.RIGHT };
+ private static final int COL_NAME = 0;
+ private static final int COL_INCLUSIVE_PER = 1;
+ private static final int COL_INCLUSIVE = 2;
+ private static final int COL_EXCLUSIVE_PER = 3;
+ private static final int COL_EXCLUSIVE = 4;
+ private static final int COL_CALLS = 5;
+ private static final int COL_TIME_PER_CALL = 6;
+ private long mTotalTime;
+ private Pattern mUppercase;
+ private int mPrevMatchIndex = -1;
+
+ public ProfileProvider(TraceReader reader) {
+ mRoots = reader.getMethods();
+ mReader = reader;
+ mTotalTime = reader.getEndTime();
+ Display display = Display.getCurrent();
+ InputStream in = getClass().getClassLoader().getResourceAsStream(
+ "icons/sort_up.png");
+ mSortUp = new Image(display, in);
+ in = getClass().getClassLoader().getResourceAsStream(
+ "icons/sort_down.png");
+ mSortDown = new Image(display, in);
+ mUppercase = Pattern.compile("[A-Z]");
+ }
+
+ private MethodData doMatchName(String name, int startIndex) {
+ // Check if the given "name" has any uppercase letters
+ boolean hasUpper = mUppercase.matcher(name).matches();
+ for (int ii = startIndex; ii < mRoots.length; ++ii) {
+ MethodData md = mRoots[ii];
+ String fullName = md.getName();
+ // If there were no upper case letters in the given name,
+ // then ignore case when matching.
+ if (!hasUpper)
+ fullName = fullName.toLowerCase();
+ if (fullName.indexOf(name) != -1) {
+ mPrevMatchIndex = ii;
+ return md;
+ }
+ }
+ mPrevMatchIndex = -1;
+ return null;
+ }
+
+ public MethodData findMatchingName(String name) {
+ return doMatchName(name, 0);
+ }
+
+ public MethodData findNextMatchingName(String name) {
+ return doMatchName(name, mPrevMatchIndex + 1);
+ }
+
+ public MethodData findMatchingTreeItem(TreeItem item) {
+ if (item == null)
+ return null;
+ String text = item.getText();
+ if (Character.isDigit(text.charAt(0)) == false)
+ return null;
+ int spaceIndex = text.indexOf(' ');
+ String numstr = text.substring(0, spaceIndex);
+ int rank = Integer.valueOf(numstr);
+ for (MethodData md : mRoots) {
+ if (md.getRank() == rank)
+ return md;
+ }
+ return null;
+ }
+
+ public void setTreeViewer(TreeViewer treeViewer) {
+ mTreeViewer = treeViewer;
+ }
+
+ public String[] getColumnNames() {
+ return mColumnNames;
+ }
+
+ public int[] getColumnWidths() {
+ return mColumnWidths;
+ }
+
+ public int[] getColumnAlignments() {
+ return mColumnAlignments;
+ }
+
+ public Object[] getChildren(Object element) {
+ if (element instanceof MethodData) {
+ MethodData md = (MethodData) element;
+ return md.getProfileNodes();
+ }
+ if (element instanceof ProfileNode) {
+ ProfileNode pn = (ProfileNode) element;
+ return pn.getChildren();
+ }
+ return new Object[0];
+ }
+
+ public Object getParent(Object element) {
+ return null;
+ }
+
+ public boolean hasChildren(Object element) {
+ if (element instanceof MethodData)
+ return true;
+ if (element instanceof ProfileNode)
+ return true;
+ return false;
+ }
+
+ public Object[] getElements(Object element) {
+ return mRoots;
+ }
+
+ public void dispose() {
+ }
+
+ public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
+ }
+
+ public Object getRoot() {
+ return "root";
+ }
+
+ public SelectionAdapter getColumnListener() {
+ if (mListener == null)
+ mListener = new ColumnListener();
+ return mListener;
+ }
+
+ public LabelProvider getLabelProvider() {
+ return new ProfileLabelProvider();
+ }
+
+ class ProfileLabelProvider extends LabelProvider implements
+ ITableLabelProvider, IColorProvider {
+ Color colorRed;
+ Color colorParentsBack;
+ Color colorChildrenBack;
+ TraceUnits traceUnits;
+
+ public ProfileLabelProvider() {
+ Display display = Display.getCurrent();
+ colorRed = display.getSystemColor(SWT.COLOR_RED);
+ colorParentsBack = new Color(display, 230, 230, 255); // blue
+ colorChildrenBack = new Color(display, 255, 255, 210); // yellow
+ traceUnits = mReader.getTraceUnits();
+ }
+
+ public String getColumnText(Object element, int col) {
+ if (element instanceof MethodData) {
+ MethodData md = (MethodData) element;
+ if (col == COL_NAME)
+ return md.getProfileName();
+ if (col == COL_EXCLUSIVE) {
+ double val = md.getElapsedExclusive();
+ val = traceUnits.getScaledValue(val);
+ return String.format("%.3f", val);
+ }
+ if (col == COL_EXCLUSIVE_PER) {
+ double val = md.getElapsedExclusive();
+ double per = val * 100.0 / mTotalTime;
+ return String.format("%.1f%%", per);
+ }
+ if (col == COL_INCLUSIVE) {
+ double val = md.getElapsedInclusive();
+ val = traceUnits.getScaledValue(val);
+ return String.format("%.3f", val);
+ }
+ if (col == COL_INCLUSIVE_PER) {
+ double val = md.getElapsedInclusive();
+ double per = val * 100.0 / mTotalTime;
+ return String.format("%.1f%%", per);
+ }
+ if (col == COL_CALLS)
+ return md.getCalls();
+ if (col == COL_TIME_PER_CALL) {
+ int numCalls = md.getTotalCalls();
+ double val = md.getElapsedInclusive();
+ val = val / numCalls;
+ val = traceUnits.getScaledValue(val);
+ return String.format("%.3f", val);
+ }
+ } else if (element instanceof ProfileSelf) {
+ ProfileSelf ps = (ProfileSelf) element;
+ if (col == COL_NAME)
+ return ps.getProfileName();
+ if (col == COL_INCLUSIVE) {
+ double val = ps.getElapsedInclusive();
+ val = traceUnits.getScaledValue(val);
+ return String.format("%.3f", val);
+ }
+ if (col == COL_INCLUSIVE_PER) {
+ double total;
+ double val = ps.getElapsedInclusive();
+ MethodData context = ps.getContext();
+ total = context.getElapsedInclusive();
+ double per = val * 100.0 / total;
+ return String.format("%.1f%%", per);
+ }
+ return "";
+ } else if (element instanceof ProfileData) {
+ ProfileData pd = (ProfileData) element;
+ if (col == COL_NAME)
+ return pd.getProfileName();
+ if (col == COL_INCLUSIVE) {
+ double val = pd.getElapsedInclusive();
+ val = traceUnits.getScaledValue(val);
+ return String.format("%.3f", val);
+ }
+ if (col == COL_INCLUSIVE_PER) {
+ double total;
+ double val = pd.getElapsedInclusive();
+ MethodData context = pd.getContext();
+ total = context.getElapsedInclusive();
+ double per = val * 100.0 / total;
+ return String.format("%.1f%%", per);
+ }
+ if (col == COL_CALLS)
+ return pd.getNumCalls();
+ return "";
+ } else if (element instanceof ProfileNode) {
+ ProfileNode pn = (ProfileNode) element;
+ if (col == COL_NAME)
+ return pn.getLabel();
+ return "";
+ }
+ return "col" + col;
+ }
+
+ public Image getColumnImage(Object element, int col) {
+ if (col != COL_NAME)
+ return null;
+ if (element instanceof MethodData) {
+ MethodData md = (MethodData) element;
+ return md.getImage();
+ }
+ if (element instanceof ProfileData) {
+ ProfileData pd = (ProfileData) element;
+ MethodData md = pd.getMethodData();
+ return md.getImage();
+ }
+ return null;
+ }
+
+ public Color getForeground(Object element) {
+ return null;
+ }
+
+ public Color getBackground(Object element) {
+ if (element instanceof ProfileData) {
+ ProfileData pd = (ProfileData) element;
+ if (pd.isParent())
+ return colorParentsBack;
+ return colorChildrenBack;
+ }
+ if (element instanceof ProfileNode) {
+ ProfileNode pn = (ProfileNode) element;
+ if (pn.isParent())
+ return colorParentsBack;
+ return colorChildrenBack;
+ }
+ return null;
+ }
+ }
+
+ class ColumnListener extends SelectionAdapter {
+ MethodData.Sorter sorter = new MethodData.Sorter();
+
+ @Override
+ public void widgetSelected(SelectionEvent event) {
+ TreeColumn column = (TreeColumn) event.widget;
+ String name = column.getText();
+ Tree tree = column.getParent();
+ tree.setRedraw(false);
+ TreeColumn[] columns = tree.getColumns();
+ for (TreeColumn col : columns) {
+ col.setImage(null);
+ }
+ if (name == mColumnNames[COL_NAME]) {
+ // Sort names alphabetically
+ sorter.setColumn(MethodData.Sorter.Column.BY_NAME);
+ Arrays.sort(mRoots, sorter);
+ } else if (name == mColumnNames[COL_EXCLUSIVE]) {
+ sorter.setColumn(MethodData.Sorter.Column.BY_EXCLUSIVE);
+ Arrays.sort(mRoots, sorter);
+ } else if (name == mColumnNames[COL_EXCLUSIVE_PER]) {
+ sorter.setColumn(MethodData.Sorter.Column.BY_EXCLUSIVE);
+ Arrays.sort(mRoots, sorter);
+ } else if (name == mColumnNames[COL_INCLUSIVE]) {
+ sorter.setColumn(MethodData.Sorter.Column.BY_INCLUSIVE);
+ Arrays.sort(mRoots, sorter);
+ } else if (name == mColumnNames[COL_INCLUSIVE_PER]) {
+ sorter.setColumn(MethodData.Sorter.Column.BY_INCLUSIVE);
+ Arrays.sort(mRoots, sorter);
+ } else if (name == mColumnNames[COL_CALLS]) {
+ sorter.setColumn(MethodData.Sorter.Column.BY_CALLS);
+ Arrays.sort(mRoots, sorter);
+ } else if (name == mColumnNames[COL_TIME_PER_CALL]) {
+ sorter.setColumn(MethodData.Sorter.Column.BY_TIME_PER_CALL);
+ Arrays.sort(mRoots, sorter);
+ }
+ MethodData.Sorter.Direction direction = sorter.getDirection();
+ if (direction == MethodData.Sorter.Direction.INCREASING)
+ column.setImage(mSortDown);
+ else
+ column.setImage(mSortUp);
+ tree.setRedraw(true);
+ mTreeViewer.refresh();
+ }
+ }
+}
OSDN Git Service
