1 files changed, 469 insertions, 0 deletions
diff --git a/tests/CanvasCompare/src/com/android/test/hwuicompare/DisplayModifier.java b/tests/CanvasCompare/src/com/android/test/hwuicompare/DisplayModifier.java
new file mode 100644
index 0000000..6022141
--- /dev/null
+++ b/tests/CanvasCompare/src/com/android/test/hwuicompare/DisplayModifier.java
@@ -0,0 +1,469 @@
+/*
+ * 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.test.hwuicompare;
+
+import java.util.LinkedHashMap;
+import java.util.Map.Entry;
+
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.graphics.RectF;
+import android.util.Log;
+
+public abstract class DisplayModifier {
+
+    // automated tests ignore any combination of operations that don't together return TOTAL_MASK
+    protected final static int TOTAL_MASK = 0x1F;
+
+    // if we're filling, ensure we're not also sweeping over stroke parameters
+    protected final static int SWEEP_STROKE_WIDTH_BIT = 0x1 << 0;
+    protected final static int SWEEP_STROKE_CAP_BIT = 0x1 << 1;
+    protected final static int SWEEP_STROKE_JOIN_BIT = 0x1 << 2;
+
+    protected final static int SWEEP_SHADER_BIT = 0x1 << 3; // only allow non-simple shaders to use rectangle drawing
+    protected final static int SWEEP_TRANSFORM_BIT = 0x1 << 4; // only sweep over specified transforms
+
+    abstract public void modifyDrawing(Paint paint, Canvas canvas);
+    protected int mask() { return 0x0; };
+
+    private static final RectF gRect = new RectF(0, 0, 200, 175);
+    private static final float[] gLinePts = new float[] {
+            100, 0, 200, 200, 200, 200, 0, 200, 0, 200, 100, 0
+    };
+    private static final float[] gPts = new float[] {
+            0, 100, 100, 0, 100, 200, 200, 100
+    };
+
+    @SuppressWarnings("serial")
+    private static final LinkedHashMap<String, LinkedHashMap<String, DisplayModifier>> gMaps = new LinkedHashMap<String, LinkedHashMap<String, DisplayModifier>>() {
+        {
+            put("aa", new LinkedHashMap<String, DisplayModifier>() {
+                {
+                    put("true", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setAntiAlias(true);
+                        }
+                    });
+                    put("false", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setAntiAlias(false);
+                        }
+                    });
+                }
+            });
+            put("style", new LinkedHashMap<String, DisplayModifier>() {
+                {
+                    put("fill", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStyle(Paint.Style.FILL);
+                        }
+                    });
+                    put("stroke", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStyle(Paint.Style.STROKE);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_STROKE_WIDTH_BIT; }
+                    });
+                    put("fillAndStroke", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStyle(Paint.Style.FILL_AND_STROKE);
+                        }
+
+                        @Override
+                        protected int mask() { return SWEEP_STROKE_WIDTH_BIT; }
+                    });
+                }
+            });
+            put("strokeWidth", new LinkedHashMap<String, DisplayModifier>() {
+                {
+                    put("hair", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStrokeWidth(0);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_STROKE_WIDTH_BIT; }
+                    });
+                    put("0.3", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStrokeWidth(0.3f);
+                        }
+                    });
+                    put("1", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStrokeWidth(1);
+                        }
+                    });
+                    put("5", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStrokeWidth(5);
+                        }
+                    });
+                }
+            });
+            put("strokeCap", new LinkedHashMap<String, DisplayModifier>() {
+                {
+                    put("butt", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStrokeCap(Paint.Cap.BUTT);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_STROKE_CAP_BIT; }
+                    });
+                    put("round", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStrokeCap(Paint.Cap.ROUND);
+                        }
+                    });
+                    put("square", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStrokeCap(Paint.Cap.SQUARE);
+                        }
+                    });
+                }
+            });
+            put("strokeJoin", new LinkedHashMap<String, DisplayModifier>() {
+                {
+                    put("bevel", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStrokeJoin(Paint.Join.BEVEL);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_STROKE_JOIN_BIT; }
+                    });
+                    put("round", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStrokeJoin(Paint.Join.ROUND);
+                        }
+                    });
+                    put("miter", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setStrokeJoin(Paint.Join.MITER);
+                        }
+                    });
+                    // TODO: add miter0, miter1 etc to test miter distances
+                }
+            });
+
+            put("transform", new LinkedHashMap<String, DisplayModifier>() {
+                {
+                    put("noTransform", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {}
+                        @Override
+                        protected int mask() { return SWEEP_TRANSFORM_BIT; };
+                    });
+                    put("rotate5", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.rotate(5);
+                        }
+                    });
+                    put("rotate45", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.rotate(5);
+                        }
+                    });
+                    put("rotate90", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.rotate(90);
+                            canvas.translate(0, -200);
+                        }
+                    });
+                    put("scale2x2", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.scale(2, 2);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_TRANSFORM_BIT; };
+                    });
+                    put("rot20scl1x4", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.rotate(20);
+                            canvas.scale(1, 4);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_TRANSFORM_BIT; };
+                    });
+                }
+            });
+
+            put("shader", new LinkedHashMap<String, DisplayModifier>() {
+                {
+                    put("noShader", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {}
+                        @Override
+                        protected int mask() { return SWEEP_SHADER_BIT; };
+                    });
+                    put("repeatShader", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setShader(ResourceModifiers.instance().mRepeatShader);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_SHADER_BIT; };
+                    });
+                    put("translatedShader", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setShader(ResourceModifiers.instance().mTranslatedShader);
+                        }
+                    });
+                    put("scaledShader", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setShader(ResourceModifiers.instance().mScaledShader);
+                        }
+                    });
+                    put("horGradient", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setShader(ResourceModifiers.instance().mHorGradient);
+                        }
+                    });
+                    put("diagGradient", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setShader(ResourceModifiers.instance().mDiagGradient);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_SHADER_BIT; };
+                    });
+                    put("vertGradient", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setShader(ResourceModifiers.instance().mVertGradient);
+                        }
+                    });
+                }
+            });
+
+            // FINAL MAP: DOES ACTUAL DRAWING
+            put("drawing", new LinkedHashMap<String, DisplayModifier>() {
+                {
+                    put("roundRect", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.drawRoundRect(gRect, 20, 20, paint);
+                        }
+                    });
+                    put("rect", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.drawRect(gRect, paint);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_SHADER_BIT | SWEEP_STROKE_CAP_BIT; };
+                    });
+                    put("circle", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.drawCircle(100, 100, 75, paint);
+                        }
+                    });
+                    put("oval", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.drawOval(gRect, paint);
+                        }
+                    });
+                    put("triLines", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.drawLines(gLinePts, paint);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_STROKE_CAP_BIT; };
+                    });
+                    put("plusPoints", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.drawPoints(gPts, paint);
+                        }
+                    });
+                    put("text", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setTextSize(36);
+                            canvas.drawText("TEXTTEST", 0, 50, paint);
+                        }
+                    });
+                    put("shadowtext", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            paint.setTextSize(36);
+                            paint.setShadowLayer(3.0f, 0.0f, 3.0f, 0xffff00ff);
+                            canvas.drawText("TEXTTEST", 0, 50, paint);
+                        }
+                    });
+                    put("bitmapMesh", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.drawBitmapMesh(ResourceModifiers.instance().mBitmap, 3, 3,
+                                    ResourceModifiers.instance().mBitmapVertices, 0, null, 0, null);
+                        }
+                    });
+                    put("arc", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.drawArc(gRect, 260, 285, false, paint);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_STROKE_CAP_BIT; };
+                    });
+                    put("arcFromCenter", new DisplayModifier() {
+                        @Override
+                        public void modifyDrawing(Paint paint, Canvas canvas) {
+                            canvas.drawArc(gRect, 260, 285, true, paint);
+                        }
+                        @Override
+                        protected int mask() { return SWEEP_STROKE_JOIN_BIT; };
+                    });
+                }
+            });
+            // WARNING: DON'T PUT MORE MAPS BELOW THIS
+        }
+    };
+
+    private static LinkedHashMap<String, DisplayModifier> getMapAtIndex(int index) {
+        for (LinkedHashMap<String, DisplayModifier> map : gMaps.values()) {
+            if (index == 0) {
+                return map;
+            }
+            index--;
+        }
+        return null;
+    }
+
+    // indices instead of iterators for easier bidirectional traversal
+    private static final int mIndices[] = new int[gMaps.size()];
+    private static final String[] mLastAppliedModifications = new String[gMaps.size()];
+
+    private static boolean stepInternal(boolean forward) {
+        int modifierMapIndex = gMaps.size() - 1;
+        while (modifierMapIndex >= 0) {
+            LinkedHashMap<String, DisplayModifier> map = getMapAtIndex(modifierMapIndex);
+            mIndices[modifierMapIndex] += (forward ? 1 : -1);
+
+            if (mIndices[modifierMapIndex] >= 0 && mIndices[modifierMapIndex] < map.size()) {
+                break;
+            }
+
+            mIndices[modifierMapIndex] = (forward ? 0 : map.size() - 1);
+            modifierMapIndex--;
+        }
+        return modifierMapIndex < 0; // true if resetting
+    }
+
+    public static boolean step() {
+        boolean ret = false;
+        do {
+            ret |= stepInternal(true);
+        } while (!checkModificationStateMask());
+        return ret;
+    }
+
+    public static boolean stepBack() {
+        boolean ret = false;
+        do {
+            ret |= stepInternal(false);
+        } while (!checkModificationStateMask());
+        return ret;
+    }
+
+    private static boolean checkModificationStateMask() {
+        int operatorMask = 0x0;
+        int mapIndex = 0;
+        for (LinkedHashMap<String, DisplayModifier> map : gMaps.values()) {
+            int displayModifierIndex = mIndices[mapIndex];
+            for (Entry<String, DisplayModifier> modifierEntry : map.entrySet()) {
+                if (displayModifierIndex == 0) {
+                    mLastAppliedModifications[mapIndex] = modifierEntry.getKey();
+                    operatorMask |= modifierEntry.getValue().mask();
+                    break;
+                }
+                displayModifierIndex--;
+            }
+            mapIndex++;
+        }
+        return operatorMask == TOTAL_MASK;
+    }
+
+    public static void apply(Paint paint, Canvas canvas) {
+        int mapIndex = 0;
+        for (LinkedHashMap<String, DisplayModifier> map : gMaps.values()) {
+            int displayModifierIndex = mIndices[mapIndex];
+            for (Entry<String, DisplayModifier> modifierEntry : map.entrySet()) {
+                if (displayModifierIndex == 0) {
+                    mLastAppliedModifications[mapIndex] = modifierEntry.getKey();
+                    modifierEntry.getValue().modifyDrawing(paint, canvas);
+                    break;
+                }
+                displayModifierIndex--;
+            }
+            mapIndex++;
+        }
+    }
+
+    public static String[] getLastAppliedModifications() {
+        return mLastAppliedModifications.clone();
+    }
+
+    public static String[][] getStrings() {
+        String[][] keys = new String[gMaps.size()][];
+
+        int i = 0;
+        for (LinkedHashMap<String, DisplayModifier> map : gMaps.values()) {
+            keys[i] = new String[map.size()];
+            int j = 0;
+            for (String key : map.keySet()) {
+                keys[i][j++] = key;
+            }
+            i++;
+        }
+
+        return keys;
+    }
+
+    public static void setIndex(int mapIndex, int newIndexValue) {
+        mIndices[mapIndex] = newIndexValue;
+    }
+
+    public static int[] getIndices() {
+        return mIndices;
+    }
+}