| /* |
| * Copyright (C) 2014 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/LICENSE2.0 |
| * |
| * Unless required by applicable law or agreed to in riting, 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 android.uirendering.cts.testinfrastructure; |
| |
| import android.graphics.Canvas; |
| import android.graphics.ColorFilter; |
| import android.graphics.Paint; |
| import android.graphics.PorterDuff; |
| import android.graphics.PorterDuffColorFilter; |
| import android.graphics.PorterDuffXfermode; |
| import android.graphics.RectF; |
| import android.graphics.Xfermode; |
| |
| import java.util.ArrayList; |
| import java.util.LinkedHashMap; |
| import java.util.Map; |
| |
| /** |
| * Modifies the canvas and paint objects when called. |
| */ |
| public abstract class DisplayModifier { |
| private static final RectF gRect = new RectF(0, 0, 100, 100); |
| private static final float[] gPts = new float[]{ |
| 0, 100, 100, 0, 100, 200, 200, 100 |
| }; |
| private static final float[] gTriPts = new float[]{ |
| 75, 0, 130, 130, 130, 130, 0, 130, 0, 130, 75, 0 |
| }; |
| private static final int NUM_PARALLEL_LINES = 24; |
| private static final float[] gLinePts = new float[NUM_PARALLEL_LINES * 8 + gTriPts.length]; |
| protected static final int MODIFIER_WIDTH = 180; |
| protected static final int MODIFIER_HEIGHT = 180; |
| |
| public static final PorterDuff.Mode[] PORTERDUFF_MODES = new PorterDuff.Mode[] { |
| PorterDuff.Mode.SRC, PorterDuff.Mode.DST, PorterDuff.Mode.SRC_OVER, |
| PorterDuff.Mode.DST_OVER, PorterDuff.Mode.SRC_IN, PorterDuff.Mode.DST_IN, |
| PorterDuff.Mode.SRC_OUT, PorterDuff.Mode.DST_OUT, PorterDuff.Mode.SRC_ATOP, |
| PorterDuff.Mode.DST_ATOP, PorterDuff.Mode.XOR, PorterDuff.Mode.MULTIPLY, |
| PorterDuff.Mode.SCREEN |
| }; |
| |
| static { |
| int index; |
| for (index = 0; index < gTriPts.length; index++) { |
| gLinePts[index] = gTriPts[index]; |
| } |
| float val = 0; |
| for (int i = 0; i < NUM_PARALLEL_LINES; i++) { |
| gLinePts[index + 0] = 150; |
| gLinePts[index + 1] = val; |
| gLinePts[index + 2] = 300; |
| gLinePts[index + 3] = val; |
| index += 4; |
| val += 8 + (2.0f / NUM_PARALLEL_LINES); |
| } |
| val = 0; |
| for (int i = 0; i < NUM_PARALLEL_LINES; i++) { |
| gLinePts[index + 0] = val; |
| gLinePts[index + 1] = 150; |
| gLinePts[index + 2] = val; |
| gLinePts[index + 3] = 300; |
| index += 4; |
| val += 8 + (2.0f / NUM_PARALLEL_LINES); |
| } |
| } |
| |
| // This linked hash map contains each of the different things that can be done to a canvas and |
| // paint object, like anti-aliasing or drawing. Within those LinkedHashMaps are the various |
| // options for that specific topic, which contains a displaymodifier which will affect the |
| // given canvas and paint objects. |
| public static final LinkedHashMap<String, LinkedHashMap<String, DisplayModifier>> sMaps = |
| 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); |
| } |
| }); |
| put("fillAndStroke", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setStyle(Paint.Style.FILL_AND_STROKE); |
| } |
| }); |
| } |
| }); |
| put("strokeWidth", new LinkedHashMap<String, DisplayModifier>() { |
| { |
| put("hair", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setStrokeWidth(0); |
| } |
| }); |
| 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("30", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setStrokeWidth(30); |
| } |
| }); |
| } |
| }); |
| put("strokeCap", new LinkedHashMap<String, DisplayModifier>() { |
| { |
| put("butt", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setStrokeCap(Paint.Cap.BUTT); |
| } |
| }); |
| 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); |
| } |
| }); |
| 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) { |
| } |
| }); |
| 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(45); |
| } |
| }); |
| 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); |
| } |
| }); |
| put("rot20scl1x4", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| canvas.rotate(20); |
| canvas.scale(1, 4); |
| } |
| }); |
| } |
| }); |
| |
| put("shader", new LinkedHashMap<String, DisplayModifier>() { |
| { |
| put("noShader", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| } |
| }); |
| put("repeatShader", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setShader(ResourceModifier.instance().repeatShader); |
| } |
| }); |
| put("translatedShader", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setShader(ResourceModifier.instance().translatedShader); |
| } |
| }); |
| put("scaledShader", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setShader(ResourceModifier.instance().scaledShader); |
| } |
| }); |
| put("composeShader", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setShader(ResourceModifier.instance().composeShader); |
| } |
| }); |
| /* |
| put("bad composeShader", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setShader(ResourceModifier.instance().nestedComposeShader); |
| } |
| }); |
| put("bad composeShader 2", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setShader( |
| ResourceModifier.instance().doubleGradientComposeShader); |
| } |
| }); |
| */ |
| put("horGradient", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setShader(ResourceModifier.instance().horGradient); |
| } |
| }); |
| put("diagGradient", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setShader(ResourceModifier.instance().diagGradient); |
| } |
| }); |
| put("vertGradient", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setShader(ResourceModifier.instance().vertGradient); |
| } |
| }); |
| put("radGradient", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setShader(ResourceModifier.instance().radGradient); |
| } |
| }); |
| put("sweepGradient", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setShader(ResourceModifier.instance().sweepGradient); |
| } |
| }); |
| } |
| }); |
| |
| put("xfermodes", new LinkedHashMap<String, DisplayModifier>() { |
| { |
| for (int i = 0 ; i < PORTERDUFF_MODES.length ; i++) { |
| put(PORTERDUFF_MODES[i].toString(), |
| new XfermodeModifier(PORTERDUFF_MODES[i])); |
| } |
| } |
| }); |
| |
| put("colorfilters", new LinkedHashMap<String, DisplayModifier>() { |
| { |
| for (int i = 0 ; i < PORTERDUFF_MODES.length ; i++) { |
| put(PORTERDUFF_MODES[i].toString(), |
| new ColorFilterModifier(PORTERDUFF_MODES[i])); |
| } |
| } |
| }); |
| |
| // 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); |
| } |
| }); |
| 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("lines", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| canvas.drawLines(gLinePts, paint); |
| } |
| }); |
| /* drawPoints does not work with zero stroke width, |
| * but it isn't a regression |
| * TODO: fix hardware canvas so that drawPoints works |
| 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(ResourceModifier.instance().bitmap, 3, 3, |
| ResourceModifier.instance().bitmapVertices, 0, null, 0, |
| null); |
| } |
| }); |
| put("arc", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| canvas.drawArc(gRect, 260, 285, false, paint); |
| } |
| }); |
| put("arcFromCenter", new DisplayModifier() { |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| canvas.drawArc(gRect, 260, 285, true, paint); |
| } |
| }); |
| } |
| }); |
| // WARNING: DON'T PUT MORE MAPS BELOW THIS |
| } |
| }; |
| |
| abstract public void modifyDrawing(Paint paint, Canvas canvas); |
| |
| public static class Accessor { |
| public final static int AA_MASK = 0x1 << 0; |
| public final static int STYLE_MASK = 0x1 << 1; |
| public final static int STROKE_WIDTH_MASK = 0x1 << 2; |
| public final static int STROKE_CAP_MASK = 0x1 << 3; |
| public final static int STROKE_JOIN_MASK = 0x1 << 4; |
| public final static int TRANSFORM_MASK = 0x1 << 5; |
| public final static int SHADER_MASK = 0x1 << 6; |
| public final static int XFERMODE_MASK = 0x1 << 7; |
| public final static int COLOR_FILTER_MASK = 0x1 << 8; |
| public final static int SHAPES_MASK = 0x1 << 9; |
| public final static int ALL_OPTIONS_MASK = (0x1 << 10) - 1; |
| public final static int SHAPES_INDEX = 9; |
| public final static int XFERMODE_INDEX = 7; |
| private final int mMask; |
| |
| private String mDebugString; |
| private int[] mIndices; |
| private LinkedHashMap<String, LinkedHashMap<String, DisplayModifier>> mDisplayMap; |
| |
| public Accessor(int mask) { |
| int totalModifiers = Integer.bitCount(mask); |
| mIndices = new int[totalModifiers]; |
| mMask = mask; |
| // Create a Display Map of the valid indices |
| mDisplayMap = new LinkedHashMap<String, LinkedHashMap<String, DisplayModifier>>(); |
| int index = 0; |
| for (String key : DisplayModifier.sMaps.keySet()) { |
| if (validIndex(index)) { |
| mDisplayMap.put(key, DisplayModifier.sMaps.get(key)); |
| } |
| index++; |
| } |
| mDebugString = ""; |
| } |
| |
| private LinkedHashMap<String, DisplayModifier> getMapAtIndex(int index) { |
| int i = 0; |
| for (LinkedHashMap<String, DisplayModifier> map : mDisplayMap.values()) { |
| if (i == index) { |
| return map; |
| } |
| i++; |
| } |
| return null; |
| } |
| |
| /** |
| * This will create the next combination of drawing commands. If we have done every combination, |
| * then we will return false. |
| * @return true if there is more combinations to do |
| */ |
| public boolean step() { |
| int modifierMapIndex = mIndices.length - 1; |
| // Start from the last map, and loop until it is at the front |
| while (modifierMapIndex >= 0) { |
| LinkedHashMap<String, DisplayModifier> map = getMapAtIndex(modifierMapIndex); |
| mIndices[modifierMapIndex]++; |
| |
| // If we are still at a valid index, then we don't need to update any others |
| if (mIndices[modifierMapIndex] < map.size()) { |
| break; |
| } |
| |
| // If we updated and it was outside the boundary, and it was the last index then |
| // we are done |
| if (modifierMapIndex == 0) { |
| return false; |
| } |
| // If we ran off the end of the map, we need to update one more down the list |
| mIndices[modifierMapIndex] = 0; |
| |
| modifierMapIndex--; |
| } |
| return true; |
| } |
| |
| /** |
| * Modifies the canvas and paint given for the particular combination currently |
| */ |
| public void modifyDrawing(Canvas canvas, Paint paint) { |
| final ArrayList<DisplayModifier> modifierArrayList = getModifierList(); |
| for (DisplayModifier modifier : modifierArrayList) { |
| modifier.modifyDrawing(paint, canvas); |
| } |
| } |
| |
| /** |
| * Gets a list of all the current modifications to be used. |
| */ |
| private ArrayList<DisplayModifier> getModifierList() { |
| ArrayList<DisplayModifier> modifierArrayList = new ArrayList<DisplayModifier>(); |
| int mapIndex = 0; |
| mDebugString = ""; |
| |
| // Through each possible category of modification |
| for (Map.Entry<String, LinkedHashMap<String, DisplayModifier>> entry : |
| mDisplayMap.entrySet()) { |
| int displayModifierIndex = mIndices[mapIndex]; |
| mDebugString += "Modification : " + entry.getKey(); |
| // Loop until we find the modification we are going to use |
| for (Map.Entry<String, DisplayModifier> modifierEntry : |
| entry.getValue().entrySet()) { |
| // Once we find the modification we want, then we will add it to the list, |
| // and the last applied modifications |
| if (displayModifierIndex == 0) { |
| mDebugString += " value : " + modifierEntry.getKey() + " "; |
| modifierArrayList.add(modifierEntry.getValue()); |
| break; |
| } |
| displayModifierIndex--; |
| } |
| mapIndex++; |
| } |
| return modifierArrayList; |
| } |
| |
| public String getDebugString() { |
| return mDebugString; |
| } |
| |
| /** |
| * Using the given masks, it tells if the map at the given index should be used, or not. |
| */ |
| private boolean validIndex(int index) { |
| return (mMask & (0x1 << index)) != 0; |
| } |
| } |
| |
| private static class XfermodeModifier extends DisplayModifier { |
| private Xfermode mXfermode; |
| |
| public XfermodeModifier(PorterDuff.Mode mode) { |
| mXfermode = new PorterDuffXfermode(mode); |
| } |
| |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setXfermode(mXfermode); |
| } |
| } |
| |
| private static class ColorFilterModifier extends DisplayModifier { |
| private static final int FILTER_COLOR = 0xFFBB0000; |
| private ColorFilter mColorFilter; |
| |
| public ColorFilterModifier(PorterDuff.Mode mode) { |
| mColorFilter = new PorterDuffColorFilter(FILTER_COLOR, mode); |
| } |
| |
| @Override |
| public void modifyDrawing(Paint paint, Canvas canvas) { |
| paint.setColorFilter(mColorFilter); |
| } |
| } |
| } |
