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/SkShader.h"  // IWYU pragma: keep
#include "include/core/SkTypes.h"
 
#include <atomic>
#include <cstddef>
#include <cstdint>
 
class SkCanvas;
class SkData;
class SkMatrix;
class SkStream;
class SkWStream;
enum class SkFilterMode;
struct SkDeserialProcs;
struct SkSerialProcs;
 
// TODO(kjlubick) Remove this after cleaning up clients
#include "include/core/SkTileMode.h"  // IWYU pragma: keep
 
class SK_API SkPicture : public SkRefCnt {
public:
    ~SkPicture() override;
 
    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:
        virtual ~AbortCallback() = default;
 
        virtual bool abort() = 0;
 
    protected:
        AbortCallback() = default;
        AbortCallback(const AbortCallback&) = delete;
        AbortCallback& operator=(const AbortCallback&) = delete;
    };
 
    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;
 
    sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy, SkFilterMode mode) const {
        return this->makeShader(tmx, tmy, mode, nullptr, nullptr);
    }
 
private:
    // Allowed subclasses.
    SkPicture();
    friend class SkBigPicture;
    friend class SkEmptyPicture;
    friend class SkPicturePriv;
 
    void serialize(SkWStream*, const SkSerialProcs*, class SkRefCntSet* typefaces,
        bool textBlobsOnly=false) const;
    static sk_sp<SkPicture> MakeFromStreamPriv(SkStream*, const SkDeserialProcs*,
                                               class SkTypefacePlayback*,
                                               int recursionLimit);
    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; }
 
    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;
    mutable std::atomic<bool> fAddedToCache{false};
};
 
#endif