original

[gb-231r1-is01/GB_2.3_IS01.git] / sdk / traceview / src / com / android / traceview / TickScaler.java

diff --git a/sdk/traceview/src/com/android/traceview/TickScaler.java b/sdk/traceview/src/com/android/traceview/TickScaler.java
new file mode 100644 (file)
index 0000000..79fa160
--- /dev/null
+++ b/sdk/traceview/src/com/android/traceview/TickScaler.java
@@ -0,0 +1,148 @@
+/*
+ * 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;
+
+class TickScaler {
+
+    private double mMinVal; // required input
+    private double mMaxVal; // required input
+    private double mRangeVal;
+    private int mNumPixels; // required input
+    private int mPixelsPerTick; // required input
+    private double mPixelsPerRange;
+    private double mTickIncrement;
+    private double mMinMajorTick;
+
+    TickScaler(double minVal, double maxVal, int numPixels, int pixelsPerTick) {
+        mMinVal = minVal;
+        mMaxVal = maxVal;
+        mNumPixels = numPixels;
+        mPixelsPerTick = pixelsPerTick;
+    }
+
+    public void setMinVal(double minVal) {
+        mMinVal = minVal;
+    }
+
+    public double getMinVal() {
+        return mMinVal;
+    }
+
+    public void setMaxVal(double maxVal) {
+        mMaxVal = maxVal;
+    }
+
+    public double getMaxVal() {
+        return mMaxVal;
+    }
+
+    public void setNumPixels(int numPixels) {
+        mNumPixels = numPixels;
+    }
+
+    public int getNumPixels() {
+        return mNumPixels;
+    }
+
+    public void setPixelsPerTick(int pixelsPerTick) {
+        mPixelsPerTick = pixelsPerTick;
+    }
+
+    public int getPixelsPerTick() {
+        return mPixelsPerTick;
+    }
+
+    public void setPixelsPerRange(double pixelsPerRange) {
+        mPixelsPerRange = pixelsPerRange;
+    }
+
+    public double getPixelsPerRange() {
+        return mPixelsPerRange;
+    }
+
+    public void setTickIncrement(double tickIncrement) {
+        mTickIncrement = tickIncrement;
+    }
+
+    public double getTickIncrement() {
+        return mTickIncrement;
+    }
+
+    public void setMinMajorTick(double minMajorTick) {
+        mMinMajorTick = minMajorTick;
+    }
+
+    public double getMinMajorTick() {
+        return mMinMajorTick;
+    }
+
+    // Convert a time value to a 0-based pixel value
+    public int valueToPixel(double value) {
+        return (int) Math.ceil(mPixelsPerRange * (value - mMinVal) - 0.5);
+    }
+
+    // Convert a time value to a 0-based fractional pixel
+    public double valueToPixelFraction(double value) {
+        return mPixelsPerRange * (value - mMinVal);
+    }
+
+    // Convert a 0-based pixel value to a time value
+    public double pixelToValue(int pixel) {
+        return mMinVal + (pixel / mPixelsPerRange);
+    }
+
+    public void computeTicks(boolean useGivenEndPoints) {
+        int numTicks = mNumPixels / mPixelsPerTick;
+        mRangeVal = mMaxVal - mMinVal;
+        mTickIncrement = mRangeVal / numTicks;
+        double dlogTickIncrement = Math.log10(mTickIncrement);
+        int logTickIncrement = (int) Math.floor(dlogTickIncrement);
+        double scale = Math.pow(10, logTickIncrement);
+        double scaledTickIncr = mTickIncrement / scale;
+        if (scaledTickIncr > 5.0)
+            scaledTickIncr = 10;
+        else if (scaledTickIncr > 2)
+            scaledTickIncr = 5;
+        else if (scaledTickIncr > 1)
+            scaledTickIncr = 2;
+        else
+            scaledTickIncr = 1;
+        mTickIncrement = scaledTickIncr * scale;
+
+        if (!useGivenEndPoints) {
+            // Round up the max val to the next minor tick
+            double minorTickIncrement = mTickIncrement / 5;
+            double dval = mMaxVal / minorTickIncrement;
+            int ival = (int) dval;
+            if (ival != dval)
+                mMaxVal = (ival + 1) * minorTickIncrement;
+
+            // Round down the min val to a multiple of tickIncrement
+            ival = (int) (mMinVal / mTickIncrement);
+            mMinVal = ival * mTickIncrement;
+            mMinMajorTick = mMinVal;
+        } else {
+            int ival = (int) (mMinVal / mTickIncrement);
+            mMinMajorTick = ival * mTickIncrement;
+            if (mMinMajorTick < mMinVal)
+                mMinMajorTick = mMinMajorTick + mTickIncrement;
+        }
+
+        mRangeVal = mMaxVal - mMinVal;
+        mPixelsPerRange = (double) mNumPixels / mRangeVal;
+    }
+}