Something like SVG non-scaling-stroke in Android?

Question

I have a Canvas that comes from a Picture beginRecording() method.
I record things in the canvas and then call endRecording().
I would like to be able to record strokes that will not scale when the canvas is scaled afterwards.
I cannot see something like that in the Paint class. You can setStrokeWidth(float w), but:
- If w == 0 you have something like the functionality I want, but only with 1px
- If w != 0, canvas scaling means stroke scaling too.
Any ideas?

Answer 1

Extract the scale from the current transformation matrix and use the inverse of that to set your stroke width.

Answer 2

This is a silly answer:

Draw your strokes X number of times with w = 0 next to each other.

Answer 3

You will probably need to keep track of your width in a custom SVG object. As the object is scaled you can find the ratio between the new width and that of the initial size and multiply that to your initial stroke width. It doesn't have to be width, it could very much well be height or diagonal. It depends on how your object is scaling.

Or you could see if this already does what you want:

http://code.google.com/p/svg-android/

Answer 4

As the solution includes extending a class I will post the details. I've not tested it extensively but only in the context I needed it.
I wanted to get a Drawable from a list of actions like the way Picture.recording() works.
Fortunately a Path object can record the actions, and then we can paint them into a canvas.
Unfortunately painting it via canvas.drawPath() does not provide the no-scaling-stroke functionality.

So thanks to the hint given by @Andrew, I've extended Shape similarly to PathShape but with some different logic in onResize()

public class NonScalingStrokePathShape extends Shape{
    private Path    mPath;
    private float   mInitialWidth;
    private float   mInitialHeight;
    private float   mCurrentWidth;    
    private float   mCurrentHeight;    

    public NonScalingStrokePathShape(Path pPath, float pInitialWidth, float pInitialHeight) {
        mPath = pPath;
        mInitialWidth = pInitialWidth;
        mInitialHeight = pInitialHeight;
        mCurrentWidth = mInitialWidth;
        mCurrentHeight = mInitialHeight;
    }

    @Override
    public void draw(Canvas canvas, Paint paint) {
        canvas.drawPath(mPath,paint);
    }

    @Override
    protected void onResize(float width, float height) {
        Matrix matrix = new Matrix();
        matrix.setScale(width / mCurrentWidth, height / mCurrentHeight);
        mCurrentWidth = width;
        mCurrentHeight = height;
        mPath.transform(matrix);
    }

    @Override
    public NonScalingStrokePathShape clone() throws CloneNotSupportedException {
        NonScalingStrokePathShape shape = (NonScalingStrokePathShape) super.clone();
        shape.mPath = new Path(mPath);
        shape.mInitialHeight =  mInitialHeight;
        shape.mInitialWidth = mInitialWidth;
        shape.mCurrentWidth = mInitialWidth;
        shape.mCurrentHeight = mInitialHeight;
        return shape;
    }

}

This can be used in a ShapeDrawable, which is a Drawable that already takes bounds resizing into account by calling the Shape resize(float w, float h) method.