SkPicture.h

Go to the documentation of this file.

/*
 * Copyright 2007 The Android Open Source Project
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef SkPicture_DEFINED
#define SkPicture_DEFINED
 
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkTileMode.h"
#include "include/core/SkTypes.h"
 
class SkCanvas;
class SkData;
struct SkDeserialProcs;
class SkImage;
class SkMatrix;
struct SkSerialProcs;
class SkShader;
class SkStream;
class SkWStream;
 
class SK_API SkPicture : public SkRefCnt {
public:
 
    static sk_sp<SkPicture> MakeFromStream(SkStream* stream,
                                           const SkDeserialProcs* procs = nullptr);
 
    static sk_sp<SkPicture> MakeFromData(const SkData* data,
                                         const SkDeserialProcs* procs = nullptr);
 
    static sk_sp<SkPicture> MakeFromData(const void* data, size_t size,
                                         const SkDeserialProcs* procs = nullptr);
 
    class SK_API AbortCallback {
    public:
 
        AbortCallback() {}
 
        virtual ~AbortCallback() {}
 
        virtual bool abort() = 0;
    };
 
    virtual void playback(SkCanvas* canvas, AbortCallback* callback = nullptr) const = 0;
 
    virtual SkRect cullRect() const = 0;
 
    uint32_t uniqueID() const { return fUniqueID; }
 
    sk_sp<SkData> serialize(const SkSerialProcs* procs = nullptr) const;
 
    void serialize(SkWStream* stream, const SkSerialProcs* procs = nullptr) const;
 
    static sk_sp<SkPicture> MakePlaceholder(SkRect cull);
 
    virtual int approximateOpCount(bool nested = false) const = 0;
 
    virtual size_t approximateBytesUsed() const = 0;
 
    sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy, SkFilterMode mode,
                               const SkMatrix* localMatrix, const SkRect* tileRect) const;
 
    // DEPRECATED
    sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy,
                               const SkMatrix* localMatrix, const SkRect* tileRect) const;
    sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy,
                               const SkMatrix* localMatrix = nullptr) const;
 
private:
    // Allowed subclasses.
    SkPicture();
    friend class SkBigPicture;
    friend class SkEmptyPicture;
    friend class SkPicturePriv;
    template <typename> friend class SkMiniPicture;
 
    void serialize(SkWStream*, const SkSerialProcs*, class SkRefCntSet* typefaces,
        bool textBlobsOnly=false) const;
    static sk_sp<SkPicture> MakeFromStream(SkStream*, const SkDeserialProcs*,
                                           class SkTypefacePlayback*);
    friend class SkPictureData;
 
    static bool StreamIsSKP(SkStream*, struct SkPictInfo*);
    static bool BufferIsSKP(class SkReadBuffer*, struct SkPictInfo*);
    friend bool SkPicture_StreamIsSKP(SkStream*, struct SkPictInfo*);
 
    // Returns NULL if this is not an SkBigPicture.
    virtual const class SkBigPicture* asSkBigPicture() const { return nullptr; }
 
    friend struct SkPathCounter;
 
    static bool IsValidPictInfo(const struct SkPictInfo& info);
    static sk_sp<SkPicture> Forwardport(const struct SkPictInfo&,
                                        const class SkPictureData*,
                                        class SkReadBuffer* buffer);
 
    struct SkPictInfo createHeader() const;
    class SkPictureData* backport() const;
 
    uint32_t fUniqueID;
};
 
#endif