| #ifndef __DEFINED__SkPdfFont |
| #define __DEFINED__SkPdfFont |
| |
| #include "SkPdfHeaders_autogen.h" |
| #include "SkPdfMapper_autogen.h" |
| |
| #include "SkTypeface.h" |
| #include "SkUtils.h" |
| #include "SkPdfGraphicsState.h" |
| #include "SkPdfUtils.h" |
| #include "SkTDict.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 = 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 bool decodeText(const SkUnencodedText& textIn, SkDecodedText* textOut) const = 0; |
| static SkPdfEncoding* fromName(const char* name); |
| }; |
| |
| SkTDict<SkPdfEncoding*>& getStandardEncodings(); |
| |
| class SkPdfToUnicode { |
| SkPdfNativeDoc* fParsed; |
| // TODO(edisonn): hide public members |
| public: |
| unsigned short* fCMapEncoding; |
| unsigned char* fCMapEncodingFlag; |
| |
| SkPdfToUnicode(SkPdfNativeDoc* parsed, SkPdfStream* stream); |
| }; |
| |
| |
| class SkPdfIdentityHEncoding : public SkPdfEncoding { |
| public: |
| 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 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 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) { |
| 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]; |
| int len = SkUTF8_FromUnichar(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 // __DEFINED__SkPdfFont |