libs/hwui/VectorDrawable.h

/*
 * Copyright (C) 2015 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.
 */

#ifndef ANDROID_HWUI_VPATH_H
#define ANDROID_HWUI_VPATH_H

#include "Canvas.h"
#include <SkBitmap.h>
#include <SkColor.h>
#include <SkCanvas.h>
#include <SkMatrix.h>
#include <SkPaint.h>
#include <SkPath.h>
#include <SkPathMeasure.h>
#include <SkRect.h>

#include <cutils/compiler.h>
#include <stddef.h>
#include <vector>
#include <string>

namespace android {
namespace uirenderer {

namespace VectorDrawable {
#define VD_SET_PROP_WITH_FLAG(field, value, flag) (VD_SET_PROP(field, value) ? (flag = true, true): false);
#define VD_SET_PROP(field, value) (value != field ? (field = value, true) : false)

/* A VectorDrawable is composed of a tree of nodes.
 * Each node can be a group node, or a path.
 * A group node can have groups or paths as children, but a path node has
 * no children.
 * One example can be:
 *                 Root Group
 *                /    |     \
 *           Group    Path    Group
 *          /     \             |
 *         Path   Path         Path
 *
 */
class ANDROID_API Node {
public:
    Node(const Node& node) {
        mName = node.mName;
    }
    Node() {}
    virtual void draw(SkCanvas* outCanvas, const SkMatrix& currentMatrix,
            float scaleX, float scaleY) = 0;
    virtual void dump() = 0;
    void setName(const char* name) {
        mName = name;
    }
    virtual ~Node(){}
protected:
    std::string mName;
};

class ANDROID_API Path : public Node {
public:
    struct ANDROID_API Data {
        std::vector<char> verbs;
        std::vector<size_t> verbSizes;
        std::vector<float> points;
        bool operator==(const Data& data) const {
            return verbs == data.verbs && verbSizes == data.verbSizes
                    && points == data.points;
        }
    };
    Path(const Data& nodes);
    Path(const Path& path);
    Path(const char* path, size_t strLength);
    Path() {}
    void dump() override;
    bool canMorph(const Data& path);
    bool canMorph(const Path& path);
    void draw(SkCanvas* outCanvas, const SkMatrix& groupStackedMatrix,
            float scaleX, float scaleY) override;
    void setPath(const char* path, size_t strLength);
    void setPathData(const Data& data);
    static float getMatrixScale(const SkMatrix& groupStackedMatrix);

protected:
    virtual const SkPath& getUpdatedPath();
    virtual void drawPath(SkCanvas *outCanvas, const SkPath& renderPath,
            float strokeScale) = 0;
    Data mData;
    SkPath mSkPath;
    bool mSkPathDirty = true;
};

class ANDROID_API FullPath: public Path {
public:
    FullPath(const FullPath& path); // for cloning
    FullPath(const char* path, size_t strLength) : Path(path, strLength) {}
    FullPath() : Path() {}
    FullPath(const Data& nodes) : Path(nodes) {}

    void updateProperties(float strokeWidth, SkColor strokeColor,
            float strokeAlpha, SkColor fillColor, float fillAlpha,
            float trimPathStart, float trimPathEnd, float trimPathOffset,
            float strokeMiterLimit, int strokeLineCap, int strokeLineJoin);
    float getStrokeWidth() {
        return mStrokeWidth;
    }
    void setStrokeWidth(float strokeWidth) {
        mStrokeWidth = strokeWidth;
    }
    SkColor getStrokeColor() {
        return mStrokeColor;
    }
    void setStrokeColor(SkColor strokeColor) {
        mStrokeColor = strokeColor;
    }
    float getStrokeAlpha() {
        return mStrokeAlpha;
    }
    void setStrokeAlpha(float strokeAlpha) {
        mStrokeAlpha = strokeAlpha;
    }
    SkColor getFillColor() {
        return mFillColor;
    }
    void setFillColor(SkColor fillColor) {
        mFillColor = fillColor;
    }
    float getFillAlpha() {
        return mFillAlpha;
    }
    void setFillAlpha(float fillAlpha) {
        mFillAlpha = fillAlpha;
    }
    float getTrimPathStart() {
        return mTrimPathStart;
    }
    void setTrimPathStart(float trimPathStart) {
        VD_SET_PROP_WITH_FLAG(mTrimPathStart, trimPathStart, mTrimDirty);
    }
    float getTrimPathEnd() {
        return mTrimPathEnd;
    }
    void setTrimPathEnd(float trimPathEnd) {
        VD_SET_PROP_WITH_FLAG(mTrimPathEnd, trimPathEnd, mTrimDirty);
    }
    float getTrimPathOffset() {
        return mTrimPathOffset;
    }
    void setTrimPathOffset(float trimPathOffset) {
        VD_SET_PROP_WITH_FLAG(mTrimPathOffset, trimPathOffset, mTrimDirty);
    }
    bool getProperties(int8_t* outProperties, int length);

protected:
    const SkPath& getUpdatedPath() override;
    void drawPath(SkCanvas* outCanvas, const SkPath& renderPath,
            float strokeScale) override;

private:
    // Applies trimming to the specified path.
    void applyTrim();
    float mStrokeWidth = 0;
    SkColor mStrokeColor = SK_ColorTRANSPARENT;
    float mStrokeAlpha = 1;
    SkColor mFillColor = SK_ColorTRANSPARENT;
    float mFillAlpha = 1;
    float mTrimPathStart = 0;
    float mTrimPathEnd = 1;
    float mTrimPathOffset = 0;
    bool mTrimDirty = true;
    SkPaint::Cap mStrokeLineCap = SkPaint::Cap::kButt_Cap;
    SkPaint::Join mStrokeLineJoin = SkPaint::Join::kMiter_Join;
    float mStrokeMiterLimit = 4;
    SkPath mTrimmedSkPath;
    SkPaint mPaint;
};

class ANDROID_API ClipPath: public Path {
public:
    ClipPath(const ClipPath& path) : Path(path) {}
    ClipPath(const char* path, size_t strLength) : Path(path, strLength) {}
    ClipPath() : Path() {}
    ClipPath(const Data& nodes) : Path(nodes) {}

protected:
    void drawPath(SkCanvas* outCanvas, const SkPath& renderPath,
            float strokeScale) override;
};

class ANDROID_API Group: public Node {
public:
    Group(const Group& group);
    Group() {}
    float getRotation() {
        return mRotate;
    }
    void setRotation(float rotation) {
        mRotate = rotation;
    }
    float getPivotX() {
        return mPivotX;
    }
    void setPivotX(float pivotX) {
        mPivotX = pivotX;
    }
    float getPivotY() {
        return mPivotY;
    }
    void setPivotY(float pivotY) {
        mPivotY = pivotY;
    }
    float getScaleX() {
        return mScaleX;
    }
    void setScaleX(float scaleX) {
        mScaleX = scaleX;
    }
    float getScaleY() {
        return mScaleY;
    }
    void setScaleY(float scaleY) {
        mScaleY = scaleY;
    }
    float getTranslateX() {
        return mTranslateX;
    }
    void setTranslateX(float translateX) {
        mTranslateX = translateX;
    }
    float getTranslateY() {
        return mTranslateY;
    }
    void setTranslateY(float translateY) {
        mTranslateY = translateY;
    }
    virtual void draw(SkCanvas* outCanvas, const SkMatrix& currentMatrix,
            float scaleX, float scaleY) override;
    void updateLocalMatrix(float rotate, float pivotX, float pivotY,
            float scaleX, float scaleY, float translateX, float translateY);
    void getLocalMatrix(SkMatrix* outMatrix);
    void addChild(Node* child);
    void dump() override;
    bool getProperties(float* outProperties, int length);

private:
    enum class Property {
        Rotate_Property = 0,
        PivotX_Property,
        PivotY_Property,
        ScaleX_Property,
        ScaleY_Property,
        TranslateX_Property,
        TranslateY_Property,
        // Count of the properties, must be at the end.
        Count,
    };
    float mRotate = 0;
    float mPivotX = 0;
    float mPivotY = 0;
    float mScaleX = 1;
    float mScaleY = 1;
    float mTranslateX = 0;
    float mTranslateY = 0;
    std::vector<Node*> mChildren;
};

class ANDROID_API Tree {
public:
    Tree(Group* rootNode) : mRootNode(rootNode) {}
    void draw(Canvas* outCanvas, SkColorFilter* colorFilter,
            const SkRect& bounds, bool needsMirroring, bool canReuseCache);
    void drawCachedBitmapWithRootAlpha(Canvas* outCanvas, SkColorFilter* filter,
            const SkRect& originalBounds);

    void updateCachedBitmap(int width, int height);
    void createCachedBitmapIfNeeded(int width, int height);
    bool canReuseBitmap(int width, int height);
    void setAllowCaching(bool allowCaching) {
        mAllowCaching = allowCaching;
    }
    bool setRootAlpha(float rootAlpha) {
        return VD_SET_PROP(mRootAlpha, rootAlpha);
    }

    float getRootAlpha() {
        return mRootAlpha;
    }
    void setViewportSize(float viewportWidth, float viewportHeight) {
        mViewportWidth = viewportWidth;
        mViewportHeight = viewportHeight;
    }

private:
    // Cap the bitmap size, such that it won't hurt the performance too much
    // and it won't crash due to a very large scale.
    // The drawable will look blurry above this size.
    const static int MAX_CACHED_BITMAP_SIZE;

    bool mCacheDirty = true;
    bool mAllowCaching = true;
    float mViewportWidth = 0;
    float mViewportHeight = 0;
    float mRootAlpha = 1.0f;

    Group* mRootNode;
    SkRect mBounds;
    SkMatrix mCanvasMatrix;
    SkPaint mPaint;
    SkPathMeasure mPathMeasure;
    SkBitmap mCachedBitmap;

};

} // namespace VectorDrawable

typedef VectorDrawable::Path::Data PathData;
} // namespace uirenderer
} // namespace android

#endif // ANDROID_HWUI_VPATH_H