SkDocument.h

/*
 * Copyright 2013 Google Inc.
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#ifndef SkDocument_DEFINED
#define SkDocument_DEFINED

#include "SkBitmap.h"
#include "SkPicture.h"
#include "SkPixelSerializer.h"
#include "SkRect.h"
#include "SkRefCnt.h"
#include "SkString.h"
#include "SkTime.h"

class SkCanvas;
class SkWStream;

#define SK_SUPPORT_LEGACY_DOCUMENT_API

#define SK_ScalarDefaultRasterDPI           72.0f

class SK_API SkDocument : public SkRefCnt {
public:
    struct OptionalTimestamp {
        SkTime::DateTime fDateTime;
        bool fEnabled;
        OptionalTimestamp() : fEnabled(false) {}
    };

    struct PDFMetadata {
        SkString fTitle;
        SkString fAuthor;
        SkString fSubject;
        SkString fKeywords;
        SkString fCreator;
        SkString fProducer;
        OptionalTimestamp fCreation;
        OptionalTimestamp fModified;
    };

    static sk_sp<SkDocument> MakePDF(SkWStream* stream,
                                     SkScalar dpi,
                                     const SkDocument::PDFMetadata& metadata,
                                     sk_sp<SkPixelSerializer> jpegEncoder,
                                     bool pdfa);

    static sk_sp<SkDocument> MakePDF(SkWStream* stream,
                                     SkScalar dpi = SK_ScalarDefaultRasterDPI) {
        return SkDocument::MakePDF(stream, dpi, SkDocument::PDFMetadata(),
                                   nullptr, false);
    }

    static sk_sp<SkDocument> MakePDF(const char outputFilePath[],
                                     SkScalar dpi = SK_ScalarDefaultRasterDPI);

    static sk_sp<SkDocument> MakeXPS(SkWStream* stream,
                                     SkScalar dpi = SK_ScalarDefaultRasterDPI);

    static sk_sp<SkDocument> MakeXPS(const char path[],
                                     SkScalar dpi = SK_ScalarDefaultRasterDPI);

#ifdef SK_SUPPORT_LEGACY_DOCUMENT_API

    static SkDocument* CreatePDF(SkWStream* stream,
                                 SkScalar dpi = SK_ScalarDefaultRasterDPI) {
        return SkDocument::MakePDF(stream, dpi, SkDocument::PDFMetadata(),
                                   nullptr, false).release();
    }

    static SkDocument* CreatePDF(SkWStream* stream,
                                 SkScalar dpi,
                                 SkPixelSerializer* jpegEncoder) {
        return SkDocument::MakePDF(stream, dpi, SkDocument::PDFMetadata(),
                                   sk_ref_sp(jpegEncoder), false).release();
    }

    static SkDocument* CreatePDF(const char outputFilePath[],
                                 SkScalar dpi = SK_ScalarDefaultRasterDPI) {
        return SkDocument::MakePDF(outputFilePath, dpi).release();
    }

#endif  // SK_SUPPORT_LEGACY_DOCUMENT_API

    SkCanvas* beginPage(SkScalar width, SkScalar height,
                        const SkRect* content = NULL);

    void endPage();

    bool close();

    void abort();

#ifdef SK_SUPPORT_LEGACY_DOCUMENT_API

    struct Attribute {
        SkString fKey, fValue;
        Attribute(const SkString& k, const SkString& v) : fKey(k), fValue(v) {}
    };
    virtual void setMetadata(const SkDocument::Attribute[],
                             int /* attributeCount */,
                             const SkTime::DateTime* /* creationDate */,
                             const SkTime::DateTime* /* modifiedDate */) {}
#endif  // SK_SUPPORT_LEGACY_DOCUMENT_API

protected:
    SkDocument(SkWStream*, void (*)(SkWStream*, bool aborted));

    // note: subclasses must call close() in their destructor, as the base class
    // cannot do this for them.
    virtual ~SkDocument();

    virtual SkCanvas* onBeginPage(SkScalar width, SkScalar height,
                                  const SkRect& content) = 0;
    virtual void onEndPage() = 0;
    virtual bool onClose(SkWStream*) = 0;
    virtual void onAbort() = 0;

    // Allows subclasses to write to the stream as pages are written.
    SkWStream* getStream() { return fStream; }

    enum State {
        kBetweenPages_State,
        kInPage_State,
        kClosed_State
    };
    State getState() const { return fState; }

private:
    SkWStream* fStream;
    void       (*fDoneProc)(SkWStream*, bool aborted);
    State      fState;

    typedef SkRefCnt INHERITED;
};

#endif