| /* |
| * Copyright 2013 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "SkCanvas.h" |
| #include "SkDevice.h" |
| #include "SkForceLinking.h" |
| #include "SkGraphics.h" |
| #include "SkImageDecoder.h" |
| #include "SkImageEncoder.h" |
| #include "SkOSFile.h" |
| #include "SkPicture.h" |
| #include "SkStream.h" |
| #include "SkTypeface.h" |
| #include "SkTArray.h" |
| |
| #include "SkPdfBasics.h" |
| #include "SkPdfNativeTokenizer.h" |
| |
| #include <iostream> |
| #include <cstdio> |
| #include <stack> |
| #include <set> |
| |
| extern "C" PdfContext* gPdfContext; |
| extern "C" SkBitmap* gDumpBitmap; |
| extern "C" SkCanvas* gDumpCanvas; |
| |
| __SK_FORCE_IMAGE_DECODER_LINKING; |
| |
| // TODO(edisonn): tool, show what objects were read at least, show the ones not even read |
| // keep for each object pos in file |
| // plug in for VS? syntax coloring, show selected object ... from the text, or from rendered x,y |
| |
| // TODO(edisonn): security - validate all the user input, all pdf! |
| |
| // TODO(edisonn): put drawtext in #ifdefs, so comparations will ignore minor changes in text positioning and font |
| // this way, we look more at other features and layout in diffs |
| |
| // TODO(edisonn): move trace dump in the get functions, and mapper ones too so it ghappens automatically |
| /* |
| #ifdef PDF_TRACE |
| std::string str; |
| pdfContext->fGraphicsState.fResources->native()->ToString(str); |
| printf("Print Tf Resources: %s\n", str.c_str()); |
| #endif |
| */ |
| |
| #include "SkPdfHeaders_autogen.h" |
| #include "SkPdfMapper_autogen.h" |
| #include "SkPdfRenderer.h" |
| |
| #include "SkPdfBasics.h" |
| #include "SkPdfUtils.h" |
| |
| #include "SkPdfFont.h" |
| |
| /* |
| * TODO(edisonn): |
| * - all font types and all ppdf font features |
| * - word spacing |
| * - load font for baidu.pdf |
| * - load font for youtube.pdf |
| * - parser for pdf from the definition already available in pdfspec_autogen.py |
| * - all docs from ~/work |
| * - encapsulate native in the pdf api so the skpdf does not know anything about native ... in progress |
| * - load gs/ especially smask and already known prop (skp) ... in progress |
| * - wrapper on classes for customizations? e.g. |
| * SkPdfPageObjectVanila - has only the basic loaders/getters |
| * SkPdfPageObject : public SkPdfPageObjectVanila, extends, and I can add customizations here |
| * need to find a nice object model for all this with constructors and factories |
| * - deal with inheritable automatically ? |
| * - deal with specific type in spec directly, add all dictionary types to known types |
| */ |
| |
| using namespace std; |
| |
| |
| |
| // TODO(edisonn): Document PdfTokenLooper and subclasses. |
| class PdfTokenLooper { |
| protected: |
| PdfTokenLooper* fParent; |
| SkPdfNativeTokenizer* fTokenizer; |
| PdfContext* fPdfContext; |
| SkCanvas* fCanvas; |
| |
| public: |
| PdfTokenLooper(PdfTokenLooper* parent, |
| SkPdfNativeTokenizer* tokenizer, |
| PdfContext* pdfContext, |
| SkCanvas* canvas) |
| : fParent(parent), fTokenizer(tokenizer), fPdfContext(pdfContext), fCanvas(canvas) {} |
| |
| virtual ~PdfTokenLooper() {} |
| |
| virtual PdfResult consumeToken(PdfToken& token) = 0; |
| virtual void loop() = 0; |
| |
| void setUp(PdfTokenLooper* parent) { |
| fParent = parent; |
| fTokenizer = parent->fTokenizer; |
| fPdfContext = parent->fPdfContext; |
| fCanvas = parent->fCanvas; |
| } |
| |
| SkPdfNativeTokenizer* tokenizer() { return fTokenizer; } |
| }; |
| |
| class PdfMainLooper : public PdfTokenLooper { |
| public: |
| PdfMainLooper(PdfTokenLooper* parent, |
| SkPdfNativeTokenizer* tokenizer, |
| PdfContext* pdfContext, |
| SkCanvas* canvas) |
| : PdfTokenLooper(parent, tokenizer, pdfContext, canvas) {} |
| |
| virtual PdfResult consumeToken(PdfToken& token); |
| virtual void loop(); |
| }; |
| |
| class PdfInlineImageLooper : public PdfTokenLooper { |
| public: |
| PdfInlineImageLooper() |
| : PdfTokenLooper(NULL, NULL, NULL, NULL) {} |
| |
| virtual PdfResult consumeToken(PdfToken& token); |
| virtual void loop(); |
| PdfResult done(); |
| }; |
| |
| class PdfCompatibilitySectionLooper : public PdfTokenLooper { |
| public: |
| PdfCompatibilitySectionLooper() |
| : PdfTokenLooper(NULL, NULL, NULL, NULL) {} |
| |
| virtual PdfResult consumeToken(PdfToken& token); |
| virtual void loop(); |
| }; |
| |
| // Utilities |
| static void setup_bitmap(SkBitmap* bitmap, int width, int height, SkColor color = SK_ColorWHITE) { |
| bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height); |
| |
| bitmap->allocPixels(); |
| bitmap->eraseColor(color); |
| } |
| |
| // TODO(edisonn): synonyms? DeviceRGB and RGB ... |
| static int GetColorSpaceComponents(const std::string& colorSpace) { |
| if (colorSpace == "DeviceCMYK") { |
| return 4; |
| } else if (colorSpace == "DeviceGray" || |
| colorSpace == "CalGray" || |
| colorSpace == "Indexed") { |
| return 1; |
| } else if (colorSpace == "DeviceRGB" || |
| colorSpace == "CalRGB" || |
| colorSpace == "Lab") { |
| return 3; |
| } else { |
| return 0; |
| } |
| } |
| |
| SkMatrix SkMatrixFromPdfMatrix(double array[6]) { |
| SkMatrix matrix; |
| matrix.setAll(SkDoubleToScalar(array[0]), |
| SkDoubleToScalar(array[2]), |
| SkDoubleToScalar(array[4]), |
| SkDoubleToScalar(array[1]), |
| SkDoubleToScalar(array[3]), |
| SkDoubleToScalar(array[5]), |
| SkDoubleToScalar(0), |
| SkDoubleToScalar(0), |
| SkDoubleToScalar(1)); |
| |
| return matrix; |
| } |
| |
| SkMatrix SkMatrixFromPdfArray(SkPdfArray* pdfArray) { |
| double array[6]; |
| |
| // TODO(edisonn): security issue, ret if size() != 6 |
| for (int i = 0; i < 6; i++) { |
| const SkPdfObject* elem = pdfArray->operator [](i); |
| if (elem == NULL || !elem->isNumber()) { |
| return SkMatrix::I(); // TODO(edisonn): report issue |
| } |
| array[i] = elem->numberValue(); |
| } |
| |
| return SkMatrixFromPdfMatrix(array); |
| } |
| |
| |
| extern "C" SkNativeParsedPDF* gDoc; |
| SkBitmap* gDumpBitmap = NULL; |
| SkCanvas* gDumpCanvas = NULL; |
| char gLastKeyword[100] = ""; |
| int gLastOpKeyword = -1; |
| char allOpWithVisualEffects[100] = ",S,s,f,F,f*,B,B*,b,b*,n,Tj,TJ,\',\",d0,d1,sh,EI,Do,EX,"; |
| int gReadOp = 0; |
| |
| |
| #ifdef PDF_TRACE_DIFF_IN_PNG |
| static bool hasVisualEffect(const char* pdfOp) { |
| return true; |
| if (*pdfOp == '\0') return false; |
| |
| char markedPdfOp[100] = ","; |
| strcat(markedPdfOp, pdfOp); |
| strcat(markedPdfOp, ","); |
| |
| return (strstr(allOpWithVisualEffects, markedPdfOp) != NULL); |
| } |
| #endif // PDF_TRACE_DIFF_IN_PNG |
| |
| |
| |
| // TODO(edisonn): Pass PdfContext and SkCanvasd only with the define for instrumentation. |
| static bool readToken(SkPdfNativeTokenizer* fTokenizer, PdfToken* token) { |
| bool ret = fTokenizer->readToken(token); |
| |
| gReadOp++; |
| |
| #ifdef PDF_TRACE_DIFF_IN_PNG |
| // TODO(edisonn): compare with old bitmap, and save only new bits are available, and save |
| // the numbar and name of last operation, so the file name will reflect op that changed. |
| if (hasVisualEffect(gLastKeyword)) { // TODO(edisonn): and has dirty bits. |
| gDumpCanvas->flush(); |
| |
| SkBitmap bitmap; |
| setup_bitmap(&bitmap, gDumpBitmap->width(), gDumpBitmap->height()); |
| |
| memcpy(bitmap.getPixels(), gDumpBitmap->getPixels(), gDumpBitmap->getSize()); |
| |
| SkAutoTUnref<SkDevice> device(SkNEW_ARGS(SkDevice, (bitmap))); |
| SkCanvas canvas(device); |
| |
| // draw context stuff here |
| SkPaint blueBorder; |
| blueBorder.setColor(SK_ColorBLUE); |
| blueBorder.setStyle(SkPaint::kStroke_Style); |
| blueBorder.setTextSize(SkDoubleToScalar(20)); |
| |
| SkString str; |
| |
| const SkClipStack* clipStack = gDumpCanvas->getClipStack(); |
| if (clipStack) { |
| SkClipStack::Iter iter(*clipStack, SkClipStack::Iter::kBottom_IterStart); |
| const SkClipStack::Element* elem; |
| double y = 0; |
| int total = 0; |
| while (elem = iter.next()) { |
| total++; |
| y += 30; |
| |
| switch (elem->getType()) { |
| case SkClipStack::Element::kRect_Type: |
| canvas.drawRect(elem->getRect(), blueBorder); |
| canvas.drawText("Rect Clip", strlen("Rect Clip"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder); |
| break; |
| case SkClipStack::Element::kPath_Type: |
| canvas.drawPath(elem->getPath(), blueBorder); |
| canvas.drawText("Path Clip", strlen("Path Clip"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder); |
| break; |
| case SkClipStack::Element::kEmpty_Type: |
| canvas.drawText("Empty Clip!!!", strlen("Empty Clip!!!"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder); |
| break; |
| default: |
| canvas.drawText("Unkown Clip!!!", strlen("Unkown Clip!!!"), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder); |
| break; |
| } |
| } |
| |
| y += 30; |
| str.printf("Number of clips in stack: %i", total); |
| canvas.drawText(str.c_str(), str.size(), SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorder); |
| } |
| |
| const SkRegion& clipRegion = gDumpCanvas->getTotalClip(); |
| SkPath clipPath; |
| if (clipRegion.getBoundaryPath(&clipPath)) { |
| SkPaint redBorder; |
| redBorder.setColor(SK_ColorRED); |
| redBorder.setStyle(SkPaint::kStroke_Style); |
| canvas.drawPath(clipPath, redBorder); |
| } |
| |
| canvas.flush(); |
| |
| SkString out; |
| |
| // TODO(edisonn): get the image, and overlay on top of it, the clip , grafic state, teh stack, |
| // ... and other properties, to be able to debug th code easily |
| |
| out.appendf("/usr/local/google/home/edisonn/log_view2/step-%i-%s.png", gLastOpKeyword, gLastKeyword); |
| SkImageEncoder::EncodeFile(out.c_str(), bitmap, SkImageEncoder::kPNG_Type, 100); |
| } |
| |
| if (token->fType == kKeyword_TokenType) { |
| strcpy(gLastKeyword, token->fKeyword); |
| gLastOpKeyword = gReadOp; |
| } else { |
| strcpy(gLastKeyword, ""); |
| } |
| #endif |
| |
| return ret; |
| } |
| |
| |
| |
| typedef PdfResult (*PdfOperatorRenderer)(PdfContext*, SkCanvas*, PdfTokenLooper**); |
| |
| map<std::string, PdfOperatorRenderer> gPdfOps; |
| |
| map<std::string, int> gRenderStats[kCount_PdfResult]; |
| |
| const char* gRenderStatsNames[kCount_PdfResult] = { |
| "Success", |
| "Partially implemented", |
| "Not yet implemented", |
| "Ignore Error", |
| "Error", |
| "Unsupported/Unknown" |
| }; |
| |
| static PdfResult DrawText(PdfContext* pdfContext, |
| const SkPdfObject* _str, |
| SkCanvas* canvas) |
| { |
| |
| SkPdfFont* skfont = pdfContext->fGraphicsState.fSkFont; |
| if (skfont == NULL) { |
| skfont = SkPdfFont::Default(); |
| } |
| |
| |
| if (_str == NULL || !_str->isAnyString()) { |
| // TODO(edisonn): report warning |
| return kIgnoreError_PdfResult; |
| } |
| const SkPdfString* str = (const SkPdfString*)_str; |
| |
| SkUnencodedText binary(str); |
| |
| SkDecodedText decoded; |
| |
| if (skfont->encoding() == NULL) { |
| // TODO(edisonn): report warning |
| return kNYI_PdfResult; |
| } |
| |
| skfont->encoding()->decodeText(binary, &decoded); |
| |
| SkPaint paint; |
| // TODO(edisonn): when should fCurFont->GetFontSize() used? When cur is fCurFontSize == 0? |
| // Or maybe just not call setTextSize at all? |
| if (pdfContext->fGraphicsState.fCurFontSize != 0) { |
| paint.setTextSize(SkDoubleToScalar(pdfContext->fGraphicsState.fCurFontSize)); |
| } |
| |
| // if (fCurFont && fCurFont->GetFontScale() != 0) { |
| // paint.setTextScaleX(SkFloatToScalar(fCurFont->GetFontScale() / 100.0)); |
| // } |
| |
| pdfContext->fGraphicsState.applyGraphicsState(&paint, false); |
| |
| canvas->save(); |
| |
| #if 1 |
| SkMatrix matrix = pdfContext->fGraphicsState.fMatrixTm; |
| |
| SkPoint point1; |
| pdfContext->fGraphicsState.fMatrixTm.mapXY(SkIntToScalar(0), SkIntToScalar(0), &point1); |
| |
| SkMatrix mirror; |
| mirror.setTranslate(0, -point1.y()); |
| // TODO(edisonn): fix rotated text, and skewed too |
| mirror.postScale(SK_Scalar1, -SK_Scalar1); |
| // TODO(edisonn): post rotate, skew |
| mirror.postTranslate(0, point1.y()); |
| |
| matrix.postConcat(mirror); |
| |
| canvas->setMatrix(matrix); |
| |
| SkTraceMatrix(matrix, "mirrored"); |
| #endif |
| |
| skfont->drawText(decoded, &paint, pdfContext, canvas); |
| canvas->restore(); |
| |
| return kPartial_PdfResult; |
| } |
| |
| // TODO(edisonn): create header files with declarations! |
| PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper); |
| PdfResult PdfOp_Q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper); |
| PdfResult PdfOp_Tw(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper); |
| PdfResult PdfOp_Tc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper); |
| |
| // TODO(edisonn): perf!!! |
| |
| static SkColorTable* getGrayColortable() { |
| static SkColorTable* grayColortable = NULL; |
| if (grayColortable == NULL) { |
| SkPMColor* colors = new SkPMColor[256]; |
| for (int i = 0 ; i < 256; i++) { |
| colors[i] = SkPreMultiplyARGB(255, i, i, i); |
| } |
| grayColortable = new SkColorTable(colors, 256); |
| } |
| return grayColortable; |
| } |
| |
| static SkBitmap transferImageStreamToBitmap(unsigned char* uncompressedStream, size_t uncompressedStreamLength, |
| int width, int height, int bytesPerLine, |
| int bpc, const std::string& colorSpace, |
| bool transparencyMask) { |
| SkBitmap bitmap; |
| |
| //int components = GetColorSpaceComponents(colorSpace); |
| //#define MAX_COMPONENTS 10 |
| |
| // TODO(edisonn): assume start of lines are aligned at 32 bits? |
| // Is there a faster way to load the uncompressed stream into a bitmap? |
| |
| // minimal support for now |
| if ((colorSpace == "DeviceRGB" || colorSpace == "RGB") && bpc == 8) { |
| SkColor* uncompressedStreamArgb = (SkColor*)malloc(width * height * sizeof(SkColor)); |
| |
| for (int h = 0 ; h < height; h++) { |
| long i = width * (h); |
| for (int w = 0 ; w < width; w++) { |
| uncompressedStreamArgb[i] = SkColorSetRGB(uncompressedStream[3 * w], |
| uncompressedStream[3 * w + 1], |
| uncompressedStream[3 * w + 2]); |
| i++; |
| } |
| uncompressedStream += bytesPerLine; |
| } |
| |
| bitmap.setConfig(SkBitmap::kARGB_8888_Config, width, height); |
| bitmap.setPixels(uncompressedStreamArgb); |
| } |
| else if ((colorSpace == "DeviceGray" || colorSpace == "Gray") && bpc == 8) { |
| unsigned char* uncompressedStreamA8 = (unsigned char*)malloc(width * height); |
| |
| for (int h = 0 ; h < height; h++) { |
| long i = width * (h); |
| for (int w = 0 ; w < width; w++) { |
| uncompressedStreamA8[i] = transparencyMask ? 255 - uncompressedStream[w] : |
| uncompressedStream[w]; |
| i++; |
| } |
| uncompressedStream += bytesPerLine; |
| } |
| |
| bitmap.setConfig(transparencyMask ? SkBitmap::kA8_Config : SkBitmap::kIndex8_Config, |
| width, height); |
| bitmap.setPixels(uncompressedStreamA8, transparencyMask ? NULL : getGrayColortable()); |
| } |
| |
| // TODO(edisonn): Report Warning, NYI, or error |
| return bitmap; |
| } |
| |
| // utils |
| |
| // TODO(edisonn): add cache, or put the bitmap property directly on the PdfObject |
| // TODO(edisonn): deal with colorSpaces, we could add them to SkBitmap::Config |
| // TODO(edisonn): preserve A1 format that skia knows, + fast convert from 111, 222, 444 to closest |
| // skia format, through a table |
| |
| // this functions returns the image, it does not look at the smask. |
| |
| static SkBitmap getImageFromObject(PdfContext* pdfContext, SkPdfImageDictionary* image, bool transparencyMask) { |
| if (image == NULL || !image->hasStream()) { |
| // TODO(edisonn): report warning to be used in testing. |
| return SkBitmap(); |
| } |
| |
| int64_t bpc = image->BitsPerComponent(pdfContext->fPdfDoc); |
| int64_t width = image->Width(pdfContext->fPdfDoc); |
| int64_t height = image->Height(pdfContext->fPdfDoc); |
| std::string colorSpace = "DeviceRGB"; |
| |
| // TODO(edisonn): color space can be an array too! |
| if (image->isColorSpaceAName(pdfContext->fPdfDoc)) { |
| colorSpace = image->getColorSpaceAsName(pdfContext->fPdfDoc); |
| } |
| |
| /* |
| bool imageMask = image->imageMask(); |
| |
| if (imageMask) { |
| if (bpc != 0 && bpc != 1) { |
| // TODO(edisonn): report warning to be used in testing. |
| return SkBitmap(); |
| } |
| bpc = 1; |
| } |
| */ |
| |
| unsigned char* uncompressedStream = NULL; |
| size_t uncompressedStreamLength = 0; |
| |
| SkPdfStream* stream = (SkPdfStream*)image; |
| |
| if (!stream || !stream->GetFilteredStreamRef(&uncompressedStream, &uncompressedStreamLength, pdfContext->fPdfDoc->allocator()) || |
| uncompressedStream == NULL || uncompressedStreamLength == 0) { |
| // TODO(edisonn): report warning to be used in testing. |
| return SkBitmap(); |
| } |
| |
| SkPdfStreamCommonDictionary* streamDict = (SkPdfStreamCommonDictionary*)stream; |
| |
| if (streamDict->has_Filter() && ((streamDict->isFilterAName(NULL) && |
| streamDict->getFilterAsName(NULL) == "DCTDecode") || |
| (streamDict->isFilterAArray(NULL) && |
| streamDict->getFilterAsArray(NULL)->size() > 0 && |
| streamDict->getFilterAsArray(NULL)->objAtAIndex(0)->isName() && |
| streamDict->getFilterAsArray(NULL)->objAtAIndex(0)->nameValue2() == "DCTDecode"))) { |
| SkBitmap bitmap; |
| SkImageDecoder::DecodeMemory(uncompressedStream, uncompressedStreamLength, &bitmap); |
| return bitmap; |
| } |
| |
| |
| |
| // TODO (edisonn): Fast Jpeg(DCTDecode) draw, or fast PNG(FlateDecode) draw ... |
| // PdfObject* value = resolveReferenceObject(pdfContext->fPdfDoc, |
| // obj.GetDictionary().GetKey(PdfName("Filter"))); |
| // if (value && value->IsArray() && value->GetArray().GetSize() == 1) { |
| // value = resolveReferenceObject(pdfContext->fPdfDoc, |
| // &value->GetArray()[0]); |
| // } |
| // if (value && value->IsName() && value->GetName().GetName() == "DCTDecode") { |
| // SkStream stream = SkStream:: |
| // SkImageDecoder::Factory() |
| // } |
| |
| int bytesPerLine = uncompressedStreamLength / height; |
| #ifdef PDF_TRACE |
| if (uncompressedStreamLength % height != 0) { |
| printf("Warning uncompressedStreamLength modulo height != 0 !!!\n"); |
| } |
| #endif |
| |
| SkBitmap bitmap = transferImageStreamToBitmap( |
| (unsigned char*)uncompressedStream, uncompressedStreamLength, |
| (int)width, (int)height, bytesPerLine, |
| (int)bpc, colorSpace, |
| transparencyMask); |
| |
| return bitmap; |
| } |
| |
| static SkBitmap getSmaskFromObject(PdfContext* pdfContext, SkPdfImageDictionary* obj) { |
| SkPdfImageDictionary* sMask = obj->SMask(pdfContext->fPdfDoc); |
| |
| if (sMask) { |
| return getImageFromObject(pdfContext, sMask, true); |
| } |
| |
| // TODO(edisonn): implement GS SMask. Default to empty right now. |
| return pdfContext->fGraphicsState.fSMask; |
| } |
| |
| static PdfResult doXObject_Image(PdfContext* pdfContext, SkCanvas* canvas, SkPdfImageDictionary* skpdfimage) { |
| if (skpdfimage == NULL) { |
| return kIgnoreError_PdfResult; |
| } |
| |
| SkBitmap image = getImageFromObject(pdfContext, skpdfimage, false); |
| SkBitmap sMask = getSmaskFromObject(pdfContext, skpdfimage); |
| |
| canvas->save(); |
| canvas->setMatrix(pdfContext->fGraphicsState.fMatrix); |
| |
| #if 1 |
| SkScalar z = SkIntToScalar(0); |
| SkScalar one = SkIntToScalar(1); |
| |
| SkPoint from[4] = {SkPoint::Make(z, z), SkPoint::Make(one, z), SkPoint::Make(one, one), SkPoint::Make(z, one)}; |
| SkPoint to[4] = {SkPoint::Make(z, one), SkPoint::Make(one, one), SkPoint::Make(one, z), SkPoint::Make(z, z)}; |
| SkMatrix flip; |
| SkAssertResult(flip.setPolyToPoly(from, to, 4)); |
| SkMatrix solveImageFlip = pdfContext->fGraphicsState.fMatrix; |
| solveImageFlip.preConcat(flip); |
| canvas->setMatrix(solveImageFlip); |
| #endif |
| |
| SkRect dst = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), SkDoubleToScalar(1.0), SkDoubleToScalar(1.0)); |
| |
| if (sMask.empty()) { |
| canvas->drawBitmapRect(image, dst, NULL); |
| } else { |
| canvas->saveLayer(&dst, NULL); |
| canvas->drawBitmapRect(image, dst, NULL); |
| SkPaint xfer; |
| pdfContext->fGraphicsState.applyGraphicsState(&xfer, false); |
| xfer.setXfermodeMode(SkXfermode::kSrcOut_Mode); // SkXfermode::kSdtOut_Mode |
| canvas->drawBitmapRect(sMask, dst, &xfer); |
| canvas->restore(); |
| } |
| |
| canvas->restore(); |
| |
| return kPartial_PdfResult; |
| } |
| |
| |
| |
| |
| static PdfResult doXObject_Form(PdfContext* pdfContext, SkCanvas* canvas, SkPdfType1FormDictionary* skobj) { |
| if (!skobj || !skobj->hasStream()) { |
| return kIgnoreError_PdfResult; |
| } |
| |
| PdfOp_q(pdfContext, canvas, NULL); |
| canvas->save(); |
| |
| |
| if (skobj->Resources(pdfContext->fPdfDoc)) { |
| pdfContext->fGraphicsState.fResources = skobj->Resources(pdfContext->fPdfDoc); |
| } |
| |
| SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Current matrix"); |
| |
| if (skobj->has_Matrix()) { |
| pdfContext->fGraphicsState.fMatrix.preConcat(skobj->Matrix(pdfContext->fPdfDoc)); |
| pdfContext->fGraphicsState.fMatrixTm = pdfContext->fGraphicsState.fMatrix; |
| pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix; |
| // TODO(edisonn) reset matrixTm and matricTlm also? |
| } |
| |
| SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Total matrix"); |
| |
| canvas->setMatrix(pdfContext->fGraphicsState.fMatrix); |
| |
| if (skobj->has_BBox()) { |
| canvas->clipRect(skobj->BBox(pdfContext->fPdfDoc), SkRegion::kIntersect_Op, true); // TODO(edisonn): AA from settings. |
| } |
| |
| // TODO(edisonn): iterate smart on the stream even if it is compressed, tokenize it as we go. |
| // For this PdfContentsTokenizer needs to be extended. |
| |
| SkPdfStream* stream = (SkPdfStream*)skobj; |
| |
| SkPdfNativeTokenizer* tokenizer = pdfContext->fPdfDoc->tokenizerOfStream(stream); |
| if (tokenizer != NULL) { |
| PdfMainLooper looper(NULL, tokenizer, pdfContext, canvas); |
| looper.loop(); |
| delete tokenizer; |
| } |
| |
| // TODO(edisonn): should we restore the variable stack at the same state? |
| // There could be operands left, that could be consumed by a parent tokenizer when we pop. |
| canvas->restore(); |
| PdfOp_Q(pdfContext, canvas, NULL); |
| return kPartial_PdfResult; |
| } |
| |
| //static PdfResult doXObject_PS(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfObject* obj) { |
| // return kNYI_PdfResult; |
| //} |
| |
| PdfResult doType3Char(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfObject* skobj, SkRect bBox, SkMatrix matrix, double textSize) { |
| if (!skobj || !skobj->hasStream()) { |
| return kIgnoreError_PdfResult; |
| } |
| |
| PdfOp_q(pdfContext, canvas, NULL); |
| canvas->save(); |
| |
| pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix); |
| pdfContext->fGraphicsState.fMatrixTm.preScale(SkDoubleToScalar(textSize), SkDoubleToScalar(textSize)); |
| |
| pdfContext->fGraphicsState.fMatrix = pdfContext->fGraphicsState.fMatrixTm; |
| pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix; |
| |
| SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "Total matrix"); |
| |
| canvas->setMatrix(pdfContext->fGraphicsState.fMatrix); |
| |
| SkRect rm = bBox; |
| pdfContext->fGraphicsState.fMatrix.mapRect(&rm); |
| |
| SkTraceRect(rm, "bbox mapped"); |
| |
| canvas->clipRect(bBox, SkRegion::kIntersect_Op, true); // TODO(edisonn): AA from settings. |
| |
| // TODO(edisonn): iterate smart on the stream even if it is compressed, tokenize it as we go. |
| // For this PdfContentsTokenizer needs to be extended. |
| |
| SkPdfStream* stream = (SkPdfStream*)skobj; |
| |
| SkPdfNativeTokenizer* tokenizer = pdfContext->fPdfDoc->tokenizerOfStream(stream); |
| if (tokenizer != NULL) { |
| PdfMainLooper looper(NULL, tokenizer, pdfContext, canvas); |
| looper.loop(); |
| delete tokenizer; |
| } |
| |
| // TODO(edisonn): should we restore the variable stack at the same state? |
| // There could be operands left, that could be consumed by a parent tokenizer when we pop. |
| canvas->restore(); |
| PdfOp_Q(pdfContext, canvas, NULL); |
| |
| return kPartial_PdfResult; |
| } |
| |
| |
| // TODO(edisonn): make sure the pointer is unique |
| std::set<const SkPdfObject*> gInRendering; |
| |
| class CheckRecursiveRendering { |
| const SkPdfObject* fUniqueData; |
| public: |
| CheckRecursiveRendering(const SkPdfObject* obj) : fUniqueData(obj) { |
| gInRendering.insert(obj); |
| } |
| |
| ~CheckRecursiveRendering() { |
| //SkASSERT(fObj.fInRendering); |
| gInRendering.erase(fUniqueData); |
| } |
| |
| static bool IsInRendering(const SkPdfObject* obj) { |
| return gInRendering.find(obj) != gInRendering.end(); |
| } |
| }; |
| |
| static PdfResult doXObject(PdfContext* pdfContext, SkCanvas* canvas, const SkPdfObject* obj) { |
| if (CheckRecursiveRendering::IsInRendering(obj)) { |
| // Oops, corrupt PDF! |
| return kIgnoreError_PdfResult; |
| } |
| |
| CheckRecursiveRendering checkRecursion(obj); |
| |
| switch (pdfContext->fPdfDoc->mapper()->mapXObjectDictionary(obj)) |
| { |
| case kImageDictionary_SkPdfObjectType: |
| return doXObject_Image(pdfContext, canvas, (SkPdfImageDictionary*)obj); |
| case kType1FormDictionary_SkPdfObjectType: |
| return doXObject_Form(pdfContext, canvas, (SkPdfType1FormDictionary*)obj); |
| //case kObjectDictionaryXObjectPS_SkPdfObjectType: |
| //return doXObject_PS(skxobj.asPS()); |
| default: |
| return kIgnoreError_PdfResult; |
| } |
| } |
| |
| PdfResult PdfOp_q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fStateStack.push(pdfContext->fGraphicsState); |
| canvas->save(); |
| return kOK_PdfResult; |
| } |
| |
| PdfResult PdfOp_Q(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fGraphicsState = pdfContext->fStateStack.top(); |
| pdfContext->fStateStack.pop(); |
| canvas->restore(); |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_cm(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| double array[6]; |
| for (int i = 0 ; i < 6 ; i++) { |
| array[5 - i] = pdfContext->fObjectStack.top()->numberValue(); |
| pdfContext->fObjectStack.pop(); |
| } |
| |
| // a b |
| // c d |
| // e f |
| |
| // 0 1 |
| // 2 3 |
| // 4 5 |
| |
| // sx ky |
| // kx sy |
| // tx ty |
| SkMatrix matrix = SkMatrixFromPdfMatrix(array); |
| |
| pdfContext->fGraphicsState.fMatrix.preConcat(matrix); |
| |
| #ifdef PDF_TRACE |
| printf("cm "); |
| for (int i = 0 ; i < 6 ; i++) { |
| printf("%f ", array[i]); |
| } |
| printf("\n"); |
| SkTraceMatrix(pdfContext->fGraphicsState.fMatrix, "cm"); |
| #endif |
| |
| return kOK_PdfResult; |
| } |
| |
| //leading TL Set the text leading, Tl |
| //, to leading, which is a number expressed in unscaled text |
| //space units. Text leading is used only by the T*, ', and " operators. Initial value: 0. |
| static PdfResult PdfOp_TL(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| double ty = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| pdfContext->fGraphicsState.fTextLeading = ty; |
| |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_Td(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| double ty = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double tx = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| double array[6] = {1, 0, 0, 1, tx, ty}; |
| SkMatrix matrix = SkMatrixFromPdfMatrix(array); |
| |
| pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix); |
| pdfContext->fGraphicsState.fMatrixTlm.preConcat(matrix); |
| |
| return kPartial_PdfResult; |
| } |
| |
| static PdfResult PdfOp_TD(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| double ty = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double tx = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| // TODO(edisonn): Create factory methods or constructors so native is hidden |
| SkPdfReal* _ty = pdfContext->fPdfDoc->createReal(-ty); |
| pdfContext->fObjectStack.push(_ty); |
| |
| PdfOp_TL(pdfContext, canvas, looper); |
| |
| SkPdfReal* vtx = pdfContext->fPdfDoc->createReal(tx); |
| pdfContext->fObjectStack.push(vtx); |
| |
| SkPdfReal* vty = pdfContext->fPdfDoc->createReal(ty); |
| pdfContext->fObjectStack.push(vty); |
| |
| PdfResult ret = PdfOp_Td(pdfContext, canvas, looper); |
| |
| // TODO(edisonn): delete all the objects after rendering was complete, in this way pdf is rendered faster |
| // and the cleanup can happen while the user looks at the image |
| |
| return ret; |
| } |
| |
| static PdfResult PdfOp_Tm(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| double f = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double e = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double d = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double c = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double b = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double a = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| double array[6]; |
| array[0] = a; |
| array[1] = b; |
| array[2] = c; |
| array[3] = d; |
| array[4] = e; |
| array[5] = f; |
| |
| SkMatrix matrix = SkMatrixFromPdfMatrix(array); |
| matrix.postConcat(pdfContext->fGraphicsState.fMatrix); |
| |
| // TODO(edisonn): Text positioning. |
| pdfContext->fGraphicsState.fMatrixTm = matrix; |
| pdfContext->fGraphicsState.fMatrixTlm = matrix;; |
| |
| return kPartial_PdfResult; |
| } |
| |
| //— T* Move to the start of the next line. This operator has the same effect as the code |
| //0 Tl Td |
| //where Tl is the current leading parameter in the text state |
| static PdfResult PdfOp_T_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| SkPdfReal* zero = pdfContext->fPdfDoc->createReal(0.0); |
| SkPdfReal* tl = pdfContext->fPdfDoc->createReal(pdfContext->fGraphicsState.fTextLeading); |
| |
| pdfContext->fObjectStack.push(zero); |
| pdfContext->fObjectStack.push(tl); |
| |
| PdfResult ret = PdfOp_Td(pdfContext, canvas, looper); |
| |
| return ret; |
| } |
| |
| static PdfResult PdfOp_m(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| if (pdfContext->fGraphicsState.fPathClosed) { |
| pdfContext->fGraphicsState.fPath.reset(); |
| pdfContext->fGraphicsState.fPathClosed = false; |
| } |
| |
| pdfContext->fGraphicsState.fCurPosY = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| pdfContext->fGraphicsState.fCurPosX = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| pdfContext->fGraphicsState.fPath.moveTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX), |
| SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY)); |
| |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_l(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| if (pdfContext->fGraphicsState.fPathClosed) { |
| pdfContext->fGraphicsState.fPath.reset(); |
| pdfContext->fGraphicsState.fPathClosed = false; |
| } |
| |
| pdfContext->fGraphicsState.fCurPosY = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| pdfContext->fGraphicsState.fCurPosX = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| pdfContext->fGraphicsState.fPath.lineTo(SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosX), |
| SkDoubleToScalar(pdfContext->fGraphicsState.fCurPosY)); |
| |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_c(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| if (pdfContext->fGraphicsState.fPathClosed) { |
| pdfContext->fGraphicsState.fPath.reset(); |
| pdfContext->fGraphicsState.fPathClosed = false; |
| } |
| |
| double y3 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double x3 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double y2 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double x2 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double y1 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double x1 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1), |
| SkDoubleToScalar(x2), SkDoubleToScalar(y2), |
| SkDoubleToScalar(x3), SkDoubleToScalar(y3)); |
| |
| pdfContext->fGraphicsState.fCurPosX = x3; |
| pdfContext->fGraphicsState.fCurPosY = y3; |
| |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_v(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| if (pdfContext->fGraphicsState.fPathClosed) { |
| pdfContext->fGraphicsState.fPath.reset(); |
| pdfContext->fGraphicsState.fPathClosed = false; |
| } |
| |
| double y3 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double x3 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double y2 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double x2 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double y1 = pdfContext->fGraphicsState.fCurPosY; |
| double x1 = pdfContext->fGraphicsState.fCurPosX; |
| |
| pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1), |
| SkDoubleToScalar(x2), SkDoubleToScalar(y2), |
| SkDoubleToScalar(x3), SkDoubleToScalar(y3)); |
| |
| pdfContext->fGraphicsState.fCurPosX = x3; |
| pdfContext->fGraphicsState.fCurPosY = y3; |
| |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_y(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| if (pdfContext->fGraphicsState.fPathClosed) { |
| pdfContext->fGraphicsState.fPath.reset(); |
| pdfContext->fGraphicsState.fPathClosed = false; |
| } |
| |
| double y3 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double x3 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double y2 = pdfContext->fGraphicsState.fCurPosY; |
| double x2 = pdfContext->fGraphicsState.fCurPosX; |
| double y1 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double x1 = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToScalar(y1), |
| SkDoubleToScalar(x2), SkDoubleToScalar(y2), |
| SkDoubleToScalar(x3), SkDoubleToScalar(y3)); |
| |
| pdfContext->fGraphicsState.fCurPosX = x3; |
| pdfContext->fGraphicsState.fCurPosY = y3; |
| |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_re(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| if (pdfContext->fGraphicsState.fPathClosed) { |
| pdfContext->fGraphicsState.fPath.reset(); |
| pdfContext->fGraphicsState.fPathClosed = false; |
| } |
| |
| double height = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double width = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double y = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double x = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| pdfContext->fGraphicsState.fPath.addRect(SkDoubleToScalar(x), SkDoubleToScalar(y), |
| SkDoubleToScalar(x + width), SkDoubleToScalar(y + height)); |
| |
| pdfContext->fGraphicsState.fCurPosX = x; |
| pdfContext->fGraphicsState.fCurPosY = y + height; |
| |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_h(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fGraphicsState.fPath.close(); |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_fillAndStroke(PdfContext* pdfContext, SkCanvas* canvas, bool fill, bool stroke, bool close, bool evenOdd) { |
| SkPath path = pdfContext->fGraphicsState.fPath; |
| |
| if (close) { |
| path.close(); |
| } |
| |
| canvas->setMatrix(pdfContext->fGraphicsState.fMatrix); |
| |
| SkPaint paint; |
| |
| SkPoint line[2]; |
| if (fill && !stroke && path.isLine(line)) { |
| paint.setStyle(SkPaint::kStroke_Style); |
| |
| pdfContext->fGraphicsState.applyGraphicsState(&paint, false); |
| paint.setStrokeWidth(SkDoubleToScalar(0)); |
| |
| canvas->drawPath(path, paint); |
| } else { |
| if (fill) { |
| paint.setStyle(SkPaint::kFill_Style); |
| if (evenOdd) { |
| path.setFillType(SkPath::kEvenOdd_FillType); |
| } |
| |
| pdfContext->fGraphicsState.applyGraphicsState(&paint, false); |
| |
| canvas->drawPath(path, paint); |
| } |
| |
| if (stroke) { |
| paint.setStyle(SkPaint::kStroke_Style); |
| |
| pdfContext->fGraphicsState.applyGraphicsState(&paint, true); |
| |
| path.setFillType(SkPath::kWinding_FillType); // reset it, just in case it messes up the stroke |
| canvas->drawPath(path, paint); |
| } |
| } |
| |
| pdfContext->fGraphicsState.fPath.reset(); |
| // todo zoom ... other stuff ? |
| |
| if (pdfContext->fGraphicsState.fHasClipPathToApply) { |
| #ifndef PDF_DEBUG_NO_CLIPING |
| canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true); |
| #endif |
| } |
| |
| //pdfContext->fGraphicsState.fClipPath.reset(); |
| pdfContext->fGraphicsState.fHasClipPathToApply = false; |
| |
| return kPartial_PdfResult; |
| |
| } |
| |
| static PdfResult PdfOp_S(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_fillAndStroke(pdfContext, canvas, false, true, false, false); |
| } |
| |
| static PdfResult PdfOp_s(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_fillAndStroke(pdfContext, canvas, false, true, true, false); |
| } |
| |
| static PdfResult PdfOp_F(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false); |
| } |
| |
| static PdfResult PdfOp_f(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false); |
| } |
| |
| static PdfResult PdfOp_f_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, true); |
| } |
| |
| static PdfResult PdfOp_B(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, false); |
| } |
| |
| static PdfResult PdfOp_B_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, true); |
| } |
| |
| static PdfResult PdfOp_b(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, false); |
| } |
| |
| static PdfResult PdfOp_b_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, true); |
| } |
| |
| static PdfResult PdfOp_n(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| canvas->setMatrix(pdfContext->fGraphicsState.fMatrix); |
| if (pdfContext->fGraphicsState.fHasClipPathToApply) { |
| #ifndef PDF_DEBUG_NO_CLIPING |
| canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kIntersect_Op, true); |
| #endif |
| } |
| |
| //pdfContext->fGraphicsState.fClipPath.reset(); |
| pdfContext->fGraphicsState.fHasClipPathToApply = false; |
| |
| pdfContext->fGraphicsState.fPathClosed = true; |
| |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_BT(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fGraphicsState.fTextBlock = true; |
| pdfContext->fGraphicsState.fMatrixTm = pdfContext->fGraphicsState.fMatrix; |
| pdfContext->fGraphicsState.fMatrixTlm = pdfContext->fGraphicsState.fMatrix; |
| |
| return kPartial_PdfResult; |
| } |
| |
| static PdfResult PdfOp_ET(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| if (!pdfContext->fGraphicsState.fTextBlock) { |
| return kIgnoreError_PdfResult; |
| } |
| // TODO(edisonn): anything else to be done once we are done with draw text? Like restore stack? |
| return kPartial_PdfResult; |
| } |
| |
| //font size Tf Set the text font, Tf |
| //, to font and the text font size, Tfs, to size. font is the name of a |
| //font resource in the Fontsubdictionary of the current resource dictionary; size is |
| //a number representing a scale factor. There is no initial value for either font or |
| //size; they must be specified explicitly using Tf before any text is shown. |
| static PdfResult PdfOp_Tf(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fGraphicsState.fCurFontSize = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| const char* fontName = pdfContext->fObjectStack.top()->nameValue(); pdfContext->fObjectStack.pop(); |
| |
| #ifdef PDF_TRACE |
| printf("font name: %s\n", fontName); |
| #endif |
| |
| if (pdfContext->fGraphicsState.fResources->Font(pdfContext->fPdfDoc)) { |
| SkPdfObject* objFont = pdfContext->fGraphicsState.fResources->Font(pdfContext->fPdfDoc)->get(fontName); |
| objFont = pdfContext->fPdfDoc->resolveReference(objFont); |
| if (kNone_SkPdfObjectType == pdfContext->fPdfDoc->mapper()->mapFontDictionary(objFont)) { |
| // TODO(edisonn): try to recover and draw it any way? |
| return kIgnoreError_PdfResult; |
| } |
| SkPdfFontDictionary* fd = (SkPdfFontDictionary*)objFont; |
| |
| SkPdfFont* skfont = SkPdfFont::fontFromPdfDictionary(pdfContext->fPdfDoc, fd); |
| |
| if (skfont) { |
| pdfContext->fGraphicsState.fSkFont = skfont; |
| } |
| } |
| return kIgnoreError_PdfResult; |
| } |
| |
| static PdfResult PdfOp_Tj(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| if (!pdfContext->fGraphicsState.fTextBlock) { |
| // TODO(edisonn): try to recover and draw it any way? |
| return kIgnoreError_PdfResult; |
| } |
| |
| PdfResult ret = DrawText(pdfContext, |
| pdfContext->fObjectStack.top(), |
| canvas); |
| pdfContext->fObjectStack.pop(); |
| |
| return ret; |
| } |
| |
| static PdfResult PdfOp_quote(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| if (!pdfContext->fGraphicsState.fTextBlock) { |
| // TODO(edisonn): try to recover and draw it any way? |
| return kIgnoreError_PdfResult; |
| } |
| |
| PdfOp_T_star(pdfContext, canvas, looper); |
| // Do not pop, and push, just transfer the param to Tj |
| return PdfOp_Tj(pdfContext, canvas, looper); |
| } |
| |
| static PdfResult PdfOp_doublequote(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| if (!pdfContext->fGraphicsState.fTextBlock) { |
| // TODO(edisonn): try to recover and draw it any way? |
| return kIgnoreError_PdfResult; |
| } |
| |
| SkPdfObject* str = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop(); |
| SkPdfObject* ac = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop(); |
| SkPdfObject* aw = pdfContext->fObjectStack.top(); pdfContext->fObjectStack.pop(); |
| |
| pdfContext->fObjectStack.push(aw); |
| PdfOp_Tw(pdfContext, canvas, looper); |
| |
| pdfContext->fObjectStack.push(ac); |
| PdfOp_Tc(pdfContext, canvas, looper); |
| |
| pdfContext->fObjectStack.push(str); |
| PdfOp_quote(pdfContext, canvas, looper); |
| |
| return kPartial_PdfResult; |
| } |
| |
| static PdfResult PdfOp_TJ(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| if (!pdfContext->fGraphicsState.fTextBlock) { |
| // TODO(edisonn): try to recover and draw it any way? |
| return kIgnoreError_PdfResult; |
| } |
| |
| SkPdfArray* array = (SkPdfArray*)pdfContext->fObjectStack.top(); |
| pdfContext->fObjectStack.pop(); |
| |
| if (!array->isArray()) { |
| return kIgnoreError_PdfResult; |
| } |
| |
| for( int i=0; i<static_cast<int>(array->size()); i++ ) |
| { |
| if( (*array)[i]->isAnyString()) { |
| SkPdfObject* obj = (*array)[i]; |
| DrawText(pdfContext, |
| obj, |
| canvas); |
| } else if ((*array)[i]->isNumber()) { |
| double dx = (*array)[i]->numberValue(); |
| SkMatrix matrix; |
| matrix.setAll(SkDoubleToScalar(1), |
| SkDoubleToScalar(0), |
| // TODO(edisonn): use writing mode, vertical/horizontal. |
| SkDoubleToScalar(-dx), // amount is substracted!!! |
| SkDoubleToScalar(0), |
| SkDoubleToScalar(1), |
| SkDoubleToScalar(0), |
| SkDoubleToScalar(0), |
| SkDoubleToScalar(0), |
| SkDoubleToScalar(1)); |
| |
| pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix); |
| } |
| } |
| return kPartial_PdfResult; // TODO(edisonn): Implement fully DrawText before returing OK. |
| } |
| |
| static PdfResult PdfOp_CS_cs(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) { |
| colorOperator->fColorSpace = pdfContext->fObjectStack.top()->nameValue(); pdfContext->fObjectStack.pop(); |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_CS(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking); |
| } |
| |
| static PdfResult PdfOp_cs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking); |
| } |
| |
| static PdfResult PdfOp_SC_sc(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) { |
| double c[4]; |
| // int64_t v[4]; |
| |
| int n = GetColorSpaceComponents(colorOperator->fColorSpace); |
| |
| bool doubles = true; |
| if (strcmp(colorOperator->fColorSpace, "Indexed") == 0) { |
| doubles = false; |
| } |
| |
| #ifdef PDF_TRACE |
| printf("color space = %s, N = %i\n", colorOperator->fColorSpace, n); |
| #endif |
| |
| for (int i = n - 1; i >= 0 ; i--) { |
| if (doubles) { |
| c[i] = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| // } else { |
| // v[i] = pdfContext->fObjectStack.top()->intValue(); pdfContext->fObjectStack.pop(); |
| } |
| } |
| |
| // TODO(edisonn): Now, set that color. Only DeviceRGB supported. |
| // TODO(edisonn): do possible field values to enum at parsing time! |
| // TODO(edisonn): support also abreviations /DeviceRGB == /RGB |
| if (strcmp(colorOperator->fColorSpace, "DeviceRGB") == 0 || strcmp(colorOperator->fColorSpace, "RGB") == 0) { |
| colorOperator->setRGBColor(SkColorSetRGB(255*c[0], 255*c[1], 255*c[2])); |
| } |
| return kPartial_PdfResult; |
| } |
| |
| static PdfResult PdfOp_SC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking); |
| } |
| |
| static PdfResult PdfOp_sc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking); |
| } |
| |
| static PdfResult PdfOp_SCN_scn(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) { |
| //SkPdfString* name; |
| if (pdfContext->fObjectStack.top()->isName()) { |
| // TODO(edisonn): get name, pass it |
| pdfContext->fObjectStack.pop(); |
| } |
| |
| // TODO(edisonn): SCN supports more color spaces than SCN. Read and implement spec. |
| PdfOp_SC_sc(pdfContext, canvas, colorOperator); |
| |
| return kPartial_PdfResult; |
| } |
| |
| static PdfResult PdfOp_SCN(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking); |
| } |
| |
| static PdfResult PdfOp_scn(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking); |
| } |
| |
| static PdfResult PdfOp_G_g(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) { |
| /*double gray = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| return kNYI_PdfResult; |
| } |
| |
| static PdfResult PdfOp_G(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking); |
| } |
| |
| static PdfResult PdfOp_g(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking); |
| } |
| |
| static PdfResult PdfOp_RG_rg(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) { |
| double b = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double g = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| double r = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| colorOperator->fColorSpace = "DeviceRGB"; |
| colorOperator->setRGBColor(SkColorSetRGB(255*r, 255*g, 255*b)); |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_RG(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking); |
| } |
| |
| static PdfResult PdfOp_rg(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking); |
| } |
| |
| static PdfResult PdfOp_K_k(PdfContext* pdfContext, SkCanvas* canvas, SkPdfColorOperator* colorOperator) { |
| // TODO(edisonn): spec has some rules about overprint, implement them. |
| /*double k = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| /*double y = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| /*double m = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| /*double c = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| colorOperator->fColorSpace = "DeviceCMYK"; |
| // TODO(edisonn): Set color. |
| return kNYI_PdfResult; |
| } |
| |
| static PdfResult PdfOp_K(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking); |
| } |
| |
| static PdfResult PdfOp_k(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStroking); |
| } |
| |
| static PdfResult PdfOp_W(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath; |
| pdfContext->fGraphicsState.fHasClipPathToApply = true; |
| |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_W_star(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath; |
| |
| #ifdef PDF_TRACE |
| if (pdfContext->fGraphicsState.fClipPath.isRect(NULL)) { |
| printf("CLIP IS RECT\n"); |
| } |
| #endif |
| |
| // TODO(edisonn): there seem to be a bug with clipPath of a rect with even odd. |
| pdfContext->fGraphicsState.fClipPath.setFillType(SkPath::kEvenOdd_FillType); |
| pdfContext->fGraphicsState.fHasClipPathToApply = true; |
| |
| return kPartial_PdfResult; |
| } |
| |
| static PdfResult PdfOp_BX(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| *looper = new PdfCompatibilitySectionLooper(); |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_EX(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| #ifdef ASSERT_BAD_PDF_OPS |
| SkASSERT(false); // EX must be consumed by PdfCompatibilitySectionLooper, but let's |
| // have the assert when testing good pdfs. |
| #endif |
| return kIgnoreError_PdfResult; |
| } |
| |
| static PdfResult PdfOp_BI(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| *looper = new PdfInlineImageLooper(); |
| return kOK_PdfResult; |
| } |
| |
| static PdfResult PdfOp_ID(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| #ifdef ASSERT_BAD_PDF_OPS |
| SkASSERT(false); // must be processed in inline image looper, but let's |
| // have the assert when testing good pdfs. |
| #endif |
| return kIgnoreError_PdfResult; |
| } |
| |
| static PdfResult PdfOp_EI(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| #ifdef ASSERT_BAD_PDF_OPS |
| SkASSERT(false); // must be processed in inline image looper, but let's |
| // have the assert when testing good pdfs. |
| #endif |
| return kIgnoreError_PdfResult; |
| } |
| |
| //lineWidth w Set the line width in the graphics state (see “Line Width” on page 152). |
| static PdfResult PdfOp_w(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| double lineWidth = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| pdfContext->fGraphicsState.fLineWidth = lineWidth; |
| |
| return kOK_PdfResult; |
| } |
| |
| //lineCap J Set the line cap style in the graphics state (see “Line Cap Style” on page 153). |
| static PdfResult PdfOp_J(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| //double lineCap = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //lineJoin j Set the line join style in the graphics state (see “Line Join Style” on page 153). |
| static PdfResult PdfOp_j(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| //double lineJoin = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //miterLimit M Set the miter limit in the graphics state (see “Miter Limit” on page 153). |
| static PdfResult PdfOp_M(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| //double miterLimit = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //dashArray dashPhase d Set the line dash pattern in the graphics state (see “Line Dash Pattern” on |
| //page 155). |
| static PdfResult PdfOp_d(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //intent ri (PDF 1.1) Set the color rendering intent in the graphics state (see “Rendering Intents” on page 197). |
| static PdfResult PdfOp_ri(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //flatness i Set the flatness tolerance in the graphics state (see Section 6.5.1, “Flatness |
| //Tolerance”). flatness is a number in the range 0 to 100; a value of 0 speci- |
| //fies the output device’s default flatness tolerance. |
| static PdfResult PdfOp_i(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //dictName gs (PDF 1.2) Set the specified parameters in the graphics state. dictName is |
| //the name of a graphics state parameter dictionary in the ExtGState subdictionary of the current resource dictionary (see the next section). |
| static PdfResult PdfOp_gs(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| const char* name = pdfContext->fObjectStack.top()->nameValue(); pdfContext->fObjectStack.pop(); |
| |
| #ifdef PDF_TRACE |
| std::string str; |
| #endif |
| |
| //Next, get the ExtGState Dictionary from the Resource Dictionary: |
| SkPdfDictionary* extGStateDictionary = pdfContext->fGraphicsState.fResources->ExtGState(pdfContext->fPdfDoc); |
| |
| if (extGStateDictionary == NULL) { |
| #ifdef PDF_TRACE |
| printf("ExtGState is NULL!\n"); |
| #endif |
| return kIgnoreError_PdfResult; |
| } |
| |
| SkPdfObject* value = pdfContext->fPdfDoc->resolveReference(extGStateDictionary->get(name)); |
| |
| if (kNone_SkPdfObjectType == pdfContext->fPdfDoc->mapper()->mapGraphicsStateDictionary(value)) { |
| return kIgnoreError_PdfResult; |
| } |
| SkPdfGraphicsStateDictionary* gs = (SkPdfGraphicsStateDictionary*)value; |
| |
| // TODO(edisonn): now load all those properties in graphic state. |
| if (gs == NULL) { |
| return kIgnoreError_PdfResult; |
| } |
| |
| if (gs->has_CA()) { |
| pdfContext->fGraphicsState.fStroking.fOpacity = gs->CA(pdfContext->fPdfDoc); |
| } |
| |
| if (gs->has_ca()) { |
| pdfContext->fGraphicsState.fNonStroking.fOpacity = gs->ca(pdfContext->fPdfDoc); |
| } |
| |
| if (gs->has_LW()) { |
| pdfContext->fGraphicsState.fLineWidth = gs->LW(pdfContext->fPdfDoc); |
| } |
| |
| return kNYI_PdfResult; |
| } |
| |
| //charSpace Tc Set the character spacing, Tc |
| //, to charSpace, which is a number expressed in unscaled text space units. Character spacing is used by the Tj, TJ, and ' operators. |
| //Initial value: 0. |
| PdfResult PdfOp_Tc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| double charSpace = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| pdfContext->fGraphicsState.fCharSpace = charSpace; |
| |
| return kOK_PdfResult; |
| } |
| |
| //wordSpace Tw Set the word spacing, T |
| //w |
| //, to wordSpace, which is a number expressed in unscaled |
| //text space units. Word spacing is used by the Tj, TJ, and ' operators. Initial |
| //value: 0. |
| PdfResult PdfOp_Tw(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| double wordSpace = pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| pdfContext->fGraphicsState.fWordSpace = wordSpace; |
| |
| return kOK_PdfResult; |
| } |
| |
| //scale Tz Set the horizontal scaling, Th |
| //, to (scale ˜ 100). scale is a number specifying the |
| //percentage of the normal width. Initial value: 100 (normal width). |
| static PdfResult PdfOp_Tz(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| /*double scale = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //render Tr Set the text rendering mode, T |
| //mode, to render, which is an integer. Initial value: 0. |
| static PdfResult PdfOp_Tr(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| /*double render = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| //rise Ts Set the text rise, Trise, to rise, which is a number expressed in unscaled text space |
| //units. Initial value: 0. |
| static PdfResult PdfOp_Ts(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| /*double rise = */pdfContext->fObjectStack.top()->numberValue(); pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //wx wy d0 |
| static PdfResult PdfOp_d0(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //wx wy llx lly urx ury d1 |
| static PdfResult PdfOp_d1(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| pdfContext->fObjectStack.pop(); |
| pdfContext->fObjectStack.pop(); |
| pdfContext->fObjectStack.pop(); |
| pdfContext->fObjectStack.pop(); |
| pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //name sh |
| static PdfResult PdfOp_sh(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //name Do |
| static PdfResult PdfOp_Do(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| const char* name = pdfContext->fObjectStack.top()->nameValue(); pdfContext->fObjectStack.pop(); |
| |
| SkPdfDictionary* xObject = pdfContext->fGraphicsState.fResources->XObject(pdfContext->fPdfDoc); |
| |
| if (xObject == NULL) { |
| #ifdef PDF_TRACE |
| printf("XObject is NULL!\n"); |
| #endif |
| return kIgnoreError_PdfResult; |
| } |
| |
| SkPdfObject* value = xObject->get(name); |
| value = pdfContext->fPdfDoc->resolveReference(value); |
| |
| #ifdef PDF_TRACE |
| // value->ToString(str); |
| // printf("Do object value: %s\n", str); |
| #endif |
| |
| return doXObject(pdfContext, canvas, value); |
| } |
| |
| //tag MP Designate a marked-content point. tag is a name object indicating the role or |
| //significance of the point. |
| static PdfResult PdfOp_MP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //tag properties DP Designate a marked-content point with an associated property list. tag is a |
| //name object indicating the role or significance of the point; properties is |
| //either an inline dictionary containing the property list or a name object |
| //associated with it in the Properties subdictionary of the current resource |
| //dictionary (see Section 9.5.1, “Property Lists”). |
| static PdfResult PdfOp_DP(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //tag BMC Begin a marked-content sequence terminated by a balancing EMC operator. |
| //tag is a name object indicating the role or significance of the sequence. |
| static PdfResult PdfOp_BMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //tag properties BDC Begin a marked-content sequence with an associated property list, terminated |
| //by a balancing EMCoperator. tag is a name object indicating the role or significance of the sequence; propertiesis either an inline dictionary containing the |
| //property list or a name object associated with it in the Properties subdictionary of the current resource dictionary (see Section 9.5.1, “Property Lists”). |
| static PdfResult PdfOp_BDC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| pdfContext->fObjectStack.pop(); |
| pdfContext->fObjectStack.pop(); |
| |
| return kNYI_PdfResult; |
| } |
| |
| //— EMC End a marked-content sequence begun by a BMC or BDC operator. |
| static PdfResult PdfOp_EMC(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) { |
| return kNYI_PdfResult; |
| } |
| |
| static void initPdfOperatorRenderes() { |
| static bool gInitialized = false; |
| if (gInitialized) { |
| return; |
| } |
| |
| gPdfOps["q"] = PdfOp_q; |
| gPdfOps["Q"] = PdfOp_Q; |
| gPdfOps["cm"] = PdfOp_cm; |
| |
| gPdfOps["TD"] = PdfOp_TD; |
| gPdfOps["Td"] = PdfOp_Td; |
| gPdfOps["Tm"] = PdfOp_Tm; |
| gPdfOps["T*"] = PdfOp_T_star; |
| |
| gPdfOps["m"] = PdfOp_m; |
| gPdfOps["l"] = PdfOp_l; |
| gPdfOps["c"] = PdfOp_c; |
| gPdfOps["v"] = PdfOp_v; |
| gPdfOps["y"] = PdfOp_y; |
| gPdfOps["h"] = PdfOp_h; |
| gPdfOps["re"] = PdfOp_re; |
| |
| gPdfOps["S"] = PdfOp_S; |
| gPdfOps["s"] = PdfOp_s; |
| gPdfOps["f"] = PdfOp_f; |
| gPdfOps["F"] = PdfOp_F; |
| gPdfOps["f*"] = PdfOp_f_star; |
| gPdfOps["B"] = PdfOp_B; |
| gPdfOps["B*"] = PdfOp_B_star; |
| gPdfOps["b"] = PdfOp_b; |
| gPdfOps["b*"] = PdfOp_b_star; |
| gPdfOps["n"] = PdfOp_n; |
| |
| gPdfOps["BT"] = PdfOp_BT; |
| gPdfOps["ET"] = PdfOp_ET; |
| |
| gPdfOps["Tj"] = PdfOp_Tj; |
| gPdfOps["'"] = PdfOp_quote; |
| gPdfOps["\""] = PdfOp_doublequote; |
| gPdfOps["TJ"] = PdfOp_TJ; |
| |
| gPdfOps["CS"] = PdfOp_CS; |
| gPdfOps["cs"] = PdfOp_cs; |
| gPdfOps["SC"] = PdfOp_SC; |
| gPdfOps["SCN"] = PdfOp_SCN; |
| gPdfOps["sc"] = PdfOp_sc; |
| gPdfOps["scn"] = PdfOp_scn; |
| gPdfOps["G"] = PdfOp_G; |
| gPdfOps["g"] = PdfOp_g; |
| gPdfOps["RG"] = PdfOp_RG; |
| gPdfOps["rg"] = PdfOp_rg; |
| gPdfOps["K"] = PdfOp_K; |
| gPdfOps["k"] = PdfOp_k; |
| |
| gPdfOps["W"] = PdfOp_W; |
| gPdfOps["W*"] = PdfOp_W_star; |
| |
| gPdfOps["BX"] = PdfOp_BX; |
| gPdfOps["EX"] = PdfOp_EX; |
| |
| gPdfOps["BI"] = PdfOp_BI; |
| gPdfOps["ID"] = PdfOp_ID; |
| gPdfOps["EI"] = PdfOp_EI; |
| |
| gPdfOps["w"] = PdfOp_w; |
| gPdfOps["J"] = PdfOp_J; |
| gPdfOps["j"] = PdfOp_j; |
| gPdfOps["M"] = PdfOp_M; |
| gPdfOps["d"] = PdfOp_d; |
| gPdfOps["ri"] = PdfOp_ri; |
| gPdfOps["i"] = PdfOp_i; |
| gPdfOps["gs"] = PdfOp_gs; |
| |
| gPdfOps["Tc"] = PdfOp_Tc; |
| gPdfOps["Tw"] = PdfOp_Tw; |
| gPdfOps["Tz"] = PdfOp_Tz; |
| gPdfOps["TL"] = PdfOp_TL; |
| gPdfOps["Tf"] = PdfOp_Tf; |
| gPdfOps["Tr"] = PdfOp_Tr; |
| gPdfOps["Ts"] = PdfOp_Ts; |
| |
| gPdfOps["d0"] = PdfOp_d0; |
| gPdfOps["d1"] = PdfOp_d1; |
| |
| gPdfOps["sh"] = PdfOp_sh; |
| |
| gPdfOps["Do"] = PdfOp_Do; |
| |
| gPdfOps["MP"] = PdfOp_MP; |
| gPdfOps["DP"] = PdfOp_DP; |
| gPdfOps["BMC"] = PdfOp_BMC; |
| gPdfOps["BDC"] = PdfOp_BDC; |
| gPdfOps["EMC"] = PdfOp_EMC; |
| |
| gInitialized = true; |
| } |
| |
| class InitPdfOps { |
| public: |
| InitPdfOps() { |
| initPdfOperatorRenderes(); |
| } |
| }; |
| |
| InitPdfOps gInitPdfOps; |
| |
| void reportPdfRenderStats() { |
| std::map<std::string, int>::iterator iter; |
| |
| for (int i = 0 ; i < kCount_PdfResult; i++) { |
| for (iter = gRenderStats[i].begin(); iter != gRenderStats[i].end(); ++iter) { |
| printf("%s: %s -> count %i\n", gRenderStatsNames[i], iter->first.c_str(), iter->second); |
| } |
| } |
| } |
| |
| PdfResult PdfMainLooper::consumeToken(PdfToken& token) { |
| char keyword[256]; |
| |
| if (token.fType == kKeyword_TokenType && token.fKeywordLength < 256) |
| { |
| strncpy(keyword, token.fKeyword, token.fKeywordLength); |
| keyword[token.fKeywordLength] = '\0'; |
| // TODO(edisonn): log trace flag (verbose, error, info, warning, ...) |
| PdfOperatorRenderer pdfOperatorRenderer = gPdfOps[keyword]; |
| if (pdfOperatorRenderer) { |
| // caller, main work is done by pdfOperatorRenderer(...) |
| PdfTokenLooper* childLooper = NULL; |
| gRenderStats[pdfOperatorRenderer(fPdfContext, fCanvas, &childLooper)][keyword]++; |
| |
| if (childLooper) { |
| childLooper->setUp(this); |
| childLooper->loop(); |
| delete childLooper; |
| } |
| } else { |
| gRenderStats[kUnsupported_PdfResult][keyword]++; |
| } |
| } |
| else if (token.fType == kObject_TokenType) |
| { |
| fPdfContext->fObjectStack.push( token.fObject ); |
| } |
| else { |
| // TODO(edisonn): deine or use assert not reached |
| return kIgnoreError_PdfResult; |
| } |
| return kOK_PdfResult; |
| } |
| |
| void PdfMainLooper::loop() { |
| PdfToken token; |
| while (readToken(fTokenizer, &token)) { |
| consumeToken(token); |
| } |
| } |
| |
| PdfResult PdfInlineImageLooper::consumeToken(PdfToken& token) { |
| SkASSERT(false); |
| return kIgnoreError_PdfResult; |
| } |
| |
| void PdfInlineImageLooper::loop() { |
| doXObject_Image(fPdfContext, fCanvas, fTokenizer->readInlineImage()); |
| } |
| |
| PdfResult PdfInlineImageLooper::done() { |
| |
| // TODO(edisonn): long to short names |
| // TODO(edisonn): set properties in a map |
| // TODO(edisonn): extract bitmap stream, check if PoDoFo has public utilities to uncompress |
| // the stream. |
| |
| SkBitmap bitmap; |
| setup_bitmap(&bitmap, 50, 50, SK_ColorRED); |
| |
| // TODO(edisonn): matrix use. |
| // Draw dummy red square, to show the prezence of the inline image. |
| fCanvas->drawBitmap(bitmap, |
| SkDoubleToScalar(0), |
| SkDoubleToScalar(0), |
| NULL); |
| return kNYI_PdfResult; |
| } |
| |
| PdfResult PdfCompatibilitySectionLooper::consumeToken(PdfToken& token) { |
| return fParent->consumeToken(token); |
| } |
| |
| void PdfCompatibilitySectionLooper::loop() { |
| // TODO(edisonn): save stacks position, or create a new stack? |
| // TODO(edisonn): what happens if we pop out more variables then when we started? |
| // restore them? fail? We could create a new operands stack for every new BX/EX section, |
| // pop-ing too much will not affect outside the section. |
| PdfToken token; |
| while (readToken(fTokenizer, &token)) { |
| if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") == 0) { |
| PdfTokenLooper* looper = new PdfCompatibilitySectionLooper(); |
| looper->setUp(this); |
| looper->loop(); |
| delete looper; |
| } else { |
| if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EX") == 0) break; |
| fParent->consumeToken(token); |
| } |
| } |
| // TODO(edisonn): restore stack. |
| } |
| |
| // TODO(edisonn): fix PoDoFo load ~/crashing/Shading.pdf |
| // TODO(edisonn): Add API for Forms viewing and editing |
| // e.g. SkBitmap getPage(int page); |
| // int formsCount(); |
| // SkForm getForm(int formID); // SkForm(SkRect, .. other data) |
| // TODO (edisonn): Add intend when loading pdf, for example: for viewing, parsing all content, ... |
| // if we load the first page, and we zoom to fit to screen horizontally, then load only those |
| // resources needed, so the preview is fast. |
| // TODO (edisonn): hide parser/tokenizer behind and interface and a query language, and resolve |
| // references automatically. |
| |
| PdfContext* gPdfContext = NULL; |
| |
| bool SkPdfRenderer::renderPage(int page, SkCanvas* canvas, const SkRect& dst) const { |
| if (!fPdfDoc) { |
| return false; |
| } |
| |
| if (page < 0 || page >= pages()) { |
| return false; |
| } |
| |
| SkPdfNativeTokenizer* tokenizer = fPdfDoc->tokenizerOfPage(page); |
| |
| PdfContext pdfContext(fPdfDoc); |
| pdfContext.fOriginalMatrix = SkMatrix::I(); |
| pdfContext.fGraphicsState.fResources = fPdfDoc->pageResources(page); |
| |
| gPdfContext = &pdfContext; |
| |
| // TODO(edisonn): get matrix stuff right. |
| SkScalar z = SkIntToScalar(0); |
| SkScalar w = dst.width(); |
| SkScalar h = dst.height(); |
| |
| SkScalar wp = fPdfDoc->MediaBox(page).width(); |
| SkScalar hp = fPdfDoc->MediaBox(page).height(); |
| |
| SkPoint pdfSpace[4] = {SkPoint::Make(z, z), SkPoint::Make(wp, z), SkPoint::Make(wp, hp), SkPoint::Make(z, hp)}; |
| // SkPoint skiaSpace[4] = {SkPoint::Make(z, h), SkPoint::Make(w, h), SkPoint::Make(w, z), SkPoint::Make(z, z)}; |
| |
| // TODO(edisonn): add flag for this app to create sourunding buffer zone |
| // TODO(edisonn): add flagg for no clipping. |
| // Use larger image to make sure we do not draw anything outside of page |
| // could be used in tests. |
| |
| #ifdef PDF_DEBUG_3X |
| SkPoint skiaSpace[4] = {SkPoint::Make(w+z, h+h), SkPoint::Make(w+w, h+h), SkPoint::Make(w+w, h+z), SkPoint::Make(w+z, h+z)}; |
| #else |
| SkPoint skiaSpace[4] = {SkPoint::Make(z, h), SkPoint::Make(w, h), SkPoint::Make(w, z), SkPoint::Make(z, z)}; |
| #endif |
| //SkPoint pdfSpace[2] = {SkPoint::Make(z, z), SkPoint::Make(w, h)}; |
| //SkPoint skiaSpace[2] = {SkPoint::Make(w, z), SkPoint::Make(z, h)}; |
| |
| //SkPoint pdfSpace[2] = {SkPoint::Make(z, z), SkPoint::Make(z, h)}; |
| //SkPoint skiaSpace[2] = {SkPoint::Make(z, h), SkPoint::Make(z, z)}; |
| |
| //SkPoint pdfSpace[3] = {SkPoint::Make(z, z), SkPoint::Make(z, h), SkPoint::Make(w, h)}; |
| //SkPoint skiaSpace[3] = {SkPoint::Make(z, h), SkPoint::Make(z, z), SkPoint::Make(w, 0)}; |
| |
| SkAssertResult(pdfContext.fOriginalMatrix.setPolyToPoly(pdfSpace, skiaSpace, 4)); |
| SkTraceMatrix(pdfContext.fOriginalMatrix, "Original matrix"); |
| |
| |
| pdfContext.fGraphicsState.fMatrix = pdfContext.fOriginalMatrix; |
| pdfContext.fGraphicsState.fMatrixTm = pdfContext.fGraphicsState.fMatrix; |
| pdfContext.fGraphicsState.fMatrixTlm = pdfContext.fGraphicsState.fMatrix; |
| |
| #ifndef PDF_DEBUG_NO_PAGE_CLIPING |
| canvas->clipRect(dst, SkRegion::kIntersect_Op, true); |
| #endif |
| |
| canvas->setMatrix(pdfContext.fOriginalMatrix); |
| |
| // erase with red before? |
| // SkPaint paint; |
| // paint.setColor(SK_ColorRED); |
| // canvas->drawRect(rect, paint); |
| |
| PdfMainLooper looper(NULL, tokenizer, &pdfContext, canvas); |
| looper.loop(); |
| |
| delete tokenizer; |
| |
| canvas->flush(); |
| return true; |
| } |
| |
| bool SkPdfRenderer::load(const SkString inputFileName) { |
| unload(); |
| |
| // TODO(edisonn): create static function that could return NULL if there are errors |
| fPdfDoc = new SkNativeParsedPDF(inputFileName.c_str()); |
| if (fPdfDoc->pages() == 0) { |
| delete fPdfDoc; |
| fPdfDoc = NULL; |
| } |
| |
| return fPdfDoc != NULL; |
| } |
| |
| int SkPdfRenderer::pages() const { |
| return fPdfDoc != NULL ? fPdfDoc->pages() : 0; |
| } |
| |
| void SkPdfRenderer::unload() { |
| delete fPdfDoc; |
| fPdfDoc = NULL; |
| } |
| |
| SkRect SkPdfRenderer::MediaBox(int page) const { |
| SkASSERT(fPdfDoc); |
| return fPdfDoc->MediaBox(page); |
| } |
| |
| size_t SkPdfRenderer::bytesUsed() const { |
| return fPdfDoc ? fPdfDoc->bytesUsed() : 0; |
| } |