xref: /external/chromium_org/third_party/skia/experimental/PdfViewer/SkPdfFont.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.
 */

// TODO(edisonn): this file not commented much on purpose.
// It will probably need heavy refactoring soon anyway to support all encodings, fonts and
// proper text sizing and spacing

#ifndef SkPdfFont_DEFINED
#define SkPdfFont_DEFINED

#include "SkPdfContext.h"
#include "SkPdfHeaders_autogen.h"
#include "SkPdfMapper_autogen.h"
#include "SkPdfUtils.h"
#include "SkTypeface.h"
#include "SkTDict.h"
#include "SkUtils.h"

class SkPdfType0Font;
class SkPdfType1Font;
class SkPdfType3Font;
class SkPdfTrueTypeFont;
class SkPdfMultiMasterFont;
class SkPdfFont;

struct SkPdfStandardFontEntry {
    // We don't own this pointer!
    const char* fName;
    bool fIsBold;
    bool fIsItalic;
    SkPdfStandardFontEntry()
    : fName(NULL),
      fIsBold(false),
      fIsItalic(false) {}

    SkPdfStandardFontEntry(const char* name, bool bold, bool italic)
        : fName(name),
          fIsBold(bold),
          fIsItalic(italic) {}
};

SkTDict<SkPdfStandardFontEntry>& getStandardFonts();
SkTypeface* SkTypefaceFromPdfStandardFont(const char* fontName, bool bold, bool italic);
SkPdfFont* fontFromName(SkPdfNativeDoc* doc, SkPdfNativeObject* obj, const char* fontName);

struct SkUnencodedText {
    void* text;
    int len;

public:
    SkUnencodedText(const SkPdfString* obj) {
        text = (void*)obj->c_str();
        len = (int) obj->lenstr();
    }
};

struct SkDecodedText {
    uint16_t* text;
    int len;
public:
    unsigned int operator[](int i) const { return text[i]; }
    int size() const { return len; }
};

struct SkUnicodeText {
    uint16_t* text;
    int len;

public:
    unsigned int operator[](int i) const { return text[i]; }
    int size() const { return len; }
};

class SkPdfEncoding {
public:
    virtual ~SkPdfEncoding() {}
    virtual bool decodeText(const SkUnencodedText& textIn, SkDecodedText* textOut) const = 0;
    static SkPdfEncoding* fromName(const char* name);
};

SkTDict<SkPdfEncoding*>& getStandardEncodings();

class SkPdfToUnicode {
    // TODO(edisonn): hide public members
public:
    unsigned short* fCMapEncoding;
    unsigned char* fCMapEncodingFlag;

    SkPdfToUnicode(SkPdfNativeDoc* parsed, SkPdfStream* stream);
};


class SkPdfIdentityHEncoding : public SkPdfEncoding {
public:
    virtual ~SkPdfIdentityHEncoding() {}
    virtual bool decodeText(const SkUnencodedText& textIn, SkDecodedText* textOut) const {
        // TODO(edisonn): SkASSERT(textIn.len % 2 == 0); or report error?

        uint16_t* text = (uint16_t*)textIn.text;
        textOut->text = new uint16_t[textIn.len / 2];
        textOut->len = textIn.len / 2;

        for (int i = 0; i < textOut->len; i++) {
            textOut->text[i] = ((text[i] << 8) & 0xff00) | ((text[i] >> 8) & 0x00ff);
        }

        return true;
    }

    static SkPdfIdentityHEncoding* instance() {
        static SkPdfIdentityHEncoding* inst = new SkPdfIdentityHEncoding();
        return inst;
    }
};

// TODO(edisonn): using this one when no encoding is specified
class SkPdfDefaultEncoding : public SkPdfEncoding {
public:
    virtual ~SkPdfDefaultEncoding() {}
    virtual bool decodeText(const SkUnencodedText& textIn, SkDecodedText* textOut) const {
        // TODO(edisonn): SkASSERT(textIn.len % 2 == 0); or report error?

        unsigned char* text = (unsigned char*)textIn.text;
        textOut->text = new uint16_t[textIn.len];
        textOut->len = textIn.len;

        for (int i = 0; i < textOut->len; i++) {
            textOut->text[i] = text[i];
        }

        return true;
    }

    static SkPdfDefaultEncoding* instance() {
        static SkPdfDefaultEncoding* inst = new SkPdfDefaultEncoding();
        return inst;
    }
};

class SkPdfCIDToGIDMapIdentityEncoding : public SkPdfEncoding {
public:
    virtual ~SkPdfCIDToGIDMapIdentityEncoding() {}
    virtual bool decodeText(const SkUnencodedText& textIn, SkDecodedText* textOut) const {
        // TODO(edisonn): SkASSERT(textIn.len % 2 == 0); or report error?

        uint16_t* text = (uint16_t*)textIn.text;
        textOut->text = new uint16_t[textIn.len / 2];
        textOut->len = textIn.len / 2;

        for (int i = 0; i < textOut->len; i++) {
            textOut->text[i] = ((text[i] << 8) & 0xff00) | ((text[i] >> 8) & 0x00ff);
        }

        return true;
    }

    static SkPdfCIDToGIDMapIdentityEncoding* instance() {
        static SkPdfCIDToGIDMapIdentityEncoding* inst = new SkPdfCIDToGIDMapIdentityEncoding();
        return inst;
    }
};

class SkPdfFont {
public:
    SkPdfFont* fBaseFont;
    SkPdfEncoding* fEncoding;
    SkPdfToUnicode* fToUnicode;


public:
    SkPdfFont() : fBaseFont(NULL), fEncoding(SkPdfDefaultEncoding::instance()), fToUnicode(NULL) {}

    virtual ~SkPdfFont() {
        // TODO(edisonn): NYI (will leak for now)
    }

    const SkPdfEncoding* encoding() const {return fEncoding;}

    void drawText(const SkDecodedText& text, SkPaint* paint, SkPdfContext* pdfContext,
                  SkCanvas* canvas) {
        for (int i = 0 ; i < text.size(); i++) {
            canvas->setMatrix(pdfContext->fGraphicsState.fMatrixTm);
#ifdef PDF_TRACE
            SkPoint point = SkPoint::Make(SkDoubleToScalar(0), SkDoubleToScalar(0));
            pdfContext->fGraphicsState.fMatrixTm.mapPoints(&point, 1);
            printf("DrawText at (%f, %f)\n", SkScalarToDouble(point.x()),
                                             SkScalarToDouble(point.y()));
#endif  // PDF_TRACE

#ifdef PDF_TRACE_DRAWTEXT
            SkPaint col;
            col.setColor(SK_ColorMAGENTA);
            SkRect rect = SkRect::MakeXYWH(SkDoubleToScalar(0.0),
                                           SkDoubleToScalar(0.0),
                                           SkDoubleToScalar(10.0),
                                           SkDoubleToScalar(10.0));
            canvas->save();
            canvas->setMatrix(pdfContext->fGraphicsState.fMatrixTm);
            canvas->drawRect(rect, col);
            canvas->restore();
#endif
            double width = drawOneChar(text[i], paint, pdfContext, canvas);
            pdfContext->fGraphicsState.fMatrixTm.preTranslate(SkDoubleToScalar(width),
                                                              SkDoubleToScalar(0.0));
        }
    }

    void ToUnicode(const SkDecodedText& textIn, SkUnicodeText* textOut) const {
        if (fToUnicode) {
            textOut->text = new uint16_t[textIn.len];
            textOut->len = textIn.len;
            for (int i = 0; i < textIn.len; i++) {
                textOut->text[i] = fToUnicode->fCMapEncoding[textIn.text[i]];
            }
        } else {
            textOut->text = textIn.text;
            textOut->len = textIn.len;
        }
    };

    inline unsigned int ToUnicode(unsigned int ch) const {
        if (fToUnicode && fToUnicode->fCMapEncoding) {
            return fToUnicode->fCMapEncoding[ch];
        } else {
            return ch;
        }
    };

    static SkPdfFont* fontFromPdfDictionary(SkPdfNativeDoc* doc, SkPdfFontDictionary* dict);
    static SkPdfFont* Default() {return fontFromName(NULL, NULL, "TimesNewRoman");}

    static SkPdfType0Font* fontFromType0FontDictionary(SkPdfNativeDoc* doc,
                                                       SkPdfType0FontDictionary* dict);
    static SkPdfType1Font* fontFromType1FontDictionary(SkPdfNativeDoc* doc,
                                                       SkPdfType1FontDictionary* dict);
    static SkPdfType3Font* fontFromType3FontDictionary(SkPdfNativeDoc* doc,
                                                       SkPdfType3FontDictionary* dict);
    static SkPdfTrueTypeFont* fontFromTrueTypeFontDictionary(SkPdfNativeDoc* doc,
                                                             SkPdfTrueTypeFontDictionary* dict);
    static SkPdfMultiMasterFont* fontFromMultiMasterFontDictionary(
            SkPdfNativeDoc* doc, SkPdfMultiMasterFontDictionary* dict);

    static SkPdfFont* fontFromFontDescriptor(SkPdfNativeDoc* doc,
                                             SkPdfFontDescriptorDictionary* fd,
                                             bool loadFromName = true);

public:
    virtual double drawOneChar(unsigned int ch, SkPaint* paint, SkPdfContext* pdfContext,
                               SkCanvas* canvas) = 0;
    virtual void afterWord(SkPaint* paint, SkMatrix* matrix) = 0;

private:
    static SkPdfFont* fontFromPdfDictionaryOnce(SkPdfNativeDoc* doc, SkPdfFontDictionary* dict);
};

class SkPdfStandardFont : public SkPdfFont {
    SkTypeface* fTypeface;

public:
    SkPdfStandardFont(SkTypeface* typeface) : fTypeface(typeface) {}

public:
    virtual double drawOneChar(unsigned int ch, SkPaint* paint, SkPdfContext* pdfContext,
                               SkCanvas* canvas) {
        paint->setTypeface(fTypeface);
        paint->setTextEncoding(SkPaint::kUTF8_TextEncoding);

        unsigned long ch4 = ch;
        char utf8[10];
        size_t len = SkUTF8_FromUnichar((SkUnichar) ch4, utf8);

        canvas->drawText(utf8, len, SkDoubleToScalar(0), SkDoubleToScalar(0), *paint);

        SkScalar textWidth = paint->measureText(utf8, len);
        return SkScalarToDouble(textWidth);
    }

    virtual void afterWord(SkPaint* paint, SkMatrix* matrix) {}
};

class SkPdfType0Font : public SkPdfFont {
public:
    SkPdfType0Font(SkPdfNativeDoc* doc, SkPdfType0FontDictionary* dict);

public:

    virtual double drawOneChar(unsigned int ch, SkPaint* paint, SkPdfContext* pdfContext,
                               SkCanvas* canvas) {
        return fBaseFont->drawOneChar(ToUnicode(ch), paint, pdfContext, canvas);
    }

    virtual void afterWord(SkPaint* paint, SkMatrix* matrix) {
    }
};

class SkPdfType1Font : public SkPdfFont {
public:
    SkPdfType1Font(SkPdfNativeDoc* doc, SkPdfType1FontDictionary* dict) {
        if (dict->has_FontDescriptor()) {
            fBaseFont = SkPdfFont::fontFromFontDescriptor(doc, dict->FontDescriptor(doc));
        } else {
            fBaseFont = fontFromName(doc, dict, dict->BaseFont(doc).c_str());
        }

        if (dict->isEncodingAName(doc)) {
            fEncoding = SkPdfEncoding::fromName(dict->getEncodingAsName(doc).c_str());
        } else if (dict->isEncodingADictionary(doc)) {
            //SkPdfDictionary* dictEnc = dict->getEncodingAsDictionary(doc);
        }
        dict->FontDescriptor(doc);
    }

public:
      virtual double drawOneChar(unsigned int ch, SkPaint* paint, SkPdfContext* pdfContext,
                                 SkCanvas* canvas) {
          return fBaseFont->drawOneChar(ToUnicode(ch), paint, pdfContext, canvas);
      }

      virtual void afterWord(SkPaint* paint, SkMatrix* matrix) {

      }
};

class SkPdfTrueTypeFont : public SkPdfType1Font {
public:
    SkPdfTrueTypeFont(SkPdfNativeDoc* doc, SkPdfTrueTypeFontDictionary* dict)
            : SkPdfType1Font(doc, dict) {}
};

class SkPdfMultiMasterFont : public SkPdfType1Font {
public:
    SkPdfMultiMasterFont(SkPdfNativeDoc* doc, SkPdfMultiMasterFontDictionary* dict)
            : SkPdfType1Font(doc, dict) {}
};
/*
class CIDToGIDMap {
    virtual unsigned int map(unsigned int cid) = 0;
    static CIDToGIDMap* fromName(const char* name);
};

class CIDToGIDMap_Identity {
    virtual unsigned int map(unsigned int cid) { return cid; }

    static CIDToGIDMap_Identity* instance() {
        static CIDToGIDMap_Identity* inst = new CIDToGIDMap_Identity();
        return inst;
    }
};

CIDToGIDMap* CIDToGIDMap::fromName(const char* name) {
    // The only one supported right now is Identity
    if (strcmp(name, "Identity") == 0) {
        return CIDToGIDMap_Identity::instance();
    }

#ifdef PDF_TRACE
    // TODO(edisonn): warning/report
    printf("Unknown CIDToGIDMap: %s\n", name);
#endif
    return NULL;
}
CIDToGIDMap* fCidToGid;
*/

class SkPdfType3Font : public SkPdfFont {
    struct Type3FontChar {
        SkPdfNativeObject* fObj;
        double fWidth;
    };

    SkPdfDictionary* fCharProcs;
    SkPdfEncodingDictionary* fEncodingDict;
    unsigned int fFirstChar;
    unsigned int fLastChar;

    SkRect fFontBBox;
    SkMatrix fFonMatrix;

    Type3FontChar* fChars;

public:
    SkPdfType3Font(SkPdfNativeDoc* parsed, SkPdfType3FontDictionary* dict) {
        fBaseFont = fontFromName(parsed, dict, dict->BaseFont(parsed).c_str());

        if (dict->has_Encoding()) {
            if (dict->isEncodingAName(parsed)) {
                 fEncoding = SkPdfEncoding::fromName(dict->getEncodingAsName(parsed).c_str());
            } else if (dict->isEncodingAEncodingdictionary(parsed)) {
                 // No encoding.
                 fEncoding = SkPdfDefaultEncoding::instance();
                 fEncodingDict = dict->getEncodingAsEncodingdictionary(parsed);
            }
        }

        // null?
        fCharProcs = dict->CharProcs(parsed);

        fToUnicode = NULL;
        if (dict->has_ToUnicode()) {
            fToUnicode = new SkPdfToUnicode(parsed, dict->ToUnicode(parsed));
        }

        fFirstChar = (unsigned int)dict->FirstChar(parsed);
        fLastChar = (unsigned int)dict->LastChar(parsed);
        fFonMatrix = dict->has_FontMatrix() ? dict->FontMatrix(parsed) : SkMatrix::I();

        if (dict->has_FontBBox()) {
            fFontBBox = dict->FontBBox(parsed);
        }

        fChars = new Type3FontChar[fLastChar - fFirstChar + 1];

        memset(fChars, 0, sizeof(fChars[0]) * (fLastChar - fFirstChar + 1));

        const SkPdfArray* widths = dict->Widths(parsed);
        for (unsigned int i = 0 ; i < widths->size(); i++) {
            if ((fFirstChar + i) >= fFirstChar && (fFirstChar + i) <= fLastChar) {
                fChars[i].fWidth = (*widths)[i]->numberValue();
            } else {
                // TODO(edisonn): report pdf corruption
            }
        }

        const SkPdfArray* diffs = fEncodingDict->Differences(parsed);
        unsigned int j = fFirstChar;
        for (unsigned int i = 0 ; i < diffs->size(); i++) {
            if ((*diffs)[i]->isInteger()) {
                j = (unsigned int)(*diffs)[i]->intValue();
            } else if ((*diffs)[i]->isName()) {
                if (j >= fFirstChar && j <= fLastChar) {
                    fChars[j - fFirstChar].fObj = fCharProcs->get((*diffs)[i]);
                } else {
                    // TODO(edisonn): report pdf corruption
                }
                j++;
            } else {
                // TODO(edisonn): report bad pdf
            }
        }
    }

public:
    virtual double drawOneChar(unsigned int ch, SkPaint* paint, SkPdfContext* pdfContext,
                               SkCanvas* canvas) {
        if (ch < fFirstChar || ch > fLastChar || !fChars[ch - fFirstChar].fObj) {
            return fBaseFont->drawOneChar(ToUnicode(ch), paint, pdfContext, canvas);
        }

#ifdef PDF_TRACE
        printf("Type 3 char to unicode: %c\n", ToUnicode(ch));
        if (ToUnicode(ch) == 'A') {
            printf("break;\n");
        }
#endif

        // TODO(edisonn): is it better to resolve the reference at load time, or now?
        doType3Char(pdfContext,
                    canvas,
                    pdfContext->fPdfDoc->resolveReference(fChars[ch - fFirstChar].fObj),
                    fFontBBox,
                    fFonMatrix,
                    pdfContext->fGraphicsState.fCurFontSize);

        // TODO(edisonn): verify/test translate code, not tested yet
        pdfContext->fGraphicsState.fMatrixTm.preTranslate(
                SkDoubleToScalar(pdfContext->fGraphicsState.fCurFontSize *
                                     fChars[ch - fFirstChar].fWidth),
                SkDoubleToScalar(0.0));
        return fChars[ch - fFirstChar].fWidth;
    }

    virtual void afterWord(SkPaint* paint, SkMatrix* matrix) {}
};

#endif  // SkPdfFont_DEFINED