skia2/experimental/PdfViewer/SkPdfFont.h
commit-bot@chromium.org d08d23b385 Small tweaks to be able to build everything target:
- fParsed is unused.
 - Quiet down a bogus -Wuninitialized warning in QWeakPointer.
Tested Clang and GCC on Linux.



BUG=
R=bungeman@google.com

Author: mtklein@google.com

Review URL: https://codereview.chromium.org/128573002

git-svn-id: http://skia.googlecode.com/svn/trunk@12970 2bbb7eff-a529-9590-31e7-b0007b416f81
2014-01-08 21:16:14 +00:00

480 lines
16 KiB
C++

/*
* 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