OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkPdfRenderer.h" | 8 #include "SkPdfRenderer.h" |
9 | 9 |
10 #include "SkBitmapDevice.h" | 10 #include "SkBitmapDevice.h" |
(...skipping 14 matching lines...) Expand all Loading... |
25 #include "SkPdfReporter.h" | 25 #include "SkPdfReporter.h" |
26 #include "SkPdfTokenLooper.h" | 26 #include "SkPdfTokenLooper.h" |
27 #include "SkPdfUtils.h" | 27 #include "SkPdfUtils.h" |
28 #include "SkStream.h" | 28 #include "SkStream.h" |
29 #include "SkTypeface.h" | 29 #include "SkTypeface.h" |
30 #include "SkTArray.h" | 30 #include "SkTArray.h" |
31 #include "SkTDict.h" | 31 #include "SkTDict.h" |
32 | 32 |
33 // TODO(edisonn): #ifdef these ones, as they are used only for debugging. | 33 // TODO(edisonn): #ifdef these ones, as they are used only for debugging. |
34 extern "C" SkPdfContext* gPdfContext; | 34 extern "C" SkPdfContext* gPdfContext; |
35 extern "C" SkBitmap* gDumpBitmap; | |
36 extern "C" SkCanvas* gDumpCanvas; | |
37 | 35 |
38 __SK_FORCE_IMAGE_DECODER_LINKING; | 36 __SK_FORCE_IMAGE_DECODER_LINKING; |
39 | 37 |
40 // TODO(edisonn): tool, show what objects were read during rendering - will help
to identify | 38 // TODO(edisonn): tool, show what objects were read during rendering - will help
to identify |
41 // features with incomplete implementation | 39 // features with incomplete implementation |
42 // TODO(edisonn): security - validate all the user input, all pdf! | 40 // TODO(edisonn): security - validate all the user input, all pdf! |
43 // TODO(edisonn): testability -add option to render without text, or only render
text | 41 // TODO(edisonn): testability -add option to render without text, or only render
text |
44 | 42 |
45 // Helper macros to load variables from stack, and automatically check their typ
e. | 43 // Helper macros to load variables from stack, and automatically check their typ
e. |
46 #define EXPECT_OPERANDS(name,pdfContext,n) \ | 44 #define EXPECT_OPERANDS(name,pdfContext,n) \ |
(...skipping 153 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
200 public: | 198 public: |
201 StringsInit() { | 199 StringsInit() { |
202 NotOwnedString::init(&strings_DeviceRGB, "DeviceRGB"); | 200 NotOwnedString::init(&strings_DeviceRGB, "DeviceRGB"); |
203 NotOwnedString::init(&strings_DeviceCMYK, "DeviceCMYK"); | 201 NotOwnedString::init(&strings_DeviceCMYK, "DeviceCMYK"); |
204 } | 202 } |
205 }; | 203 }; |
206 | 204 |
207 // TODO(edisonn): this will not work in chrome! Find another solution! | 205 // TODO(edisonn): this will not work in chrome! Find another solution! |
208 StringsInit gStringsInit; | 206 StringsInit gStringsInit; |
209 | 207 |
210 // TODO(edisonn): Document PdfTokenLooper and subclasses. | 208 // TODO(edisonn): Document SkPdfTokenLooper and subclasses. |
211 class PdfMainLooper : public PdfTokenLooper { | 209 class PdfInlineImageLooper : public SkPdfTokenLooper { |
212 public: | |
213 PdfMainLooper(PdfTokenLooper* parent, | |
214 SkPdfNativeTokenizer* tokenizer, | |
215 SkPdfContext* pdfContext, | |
216 SkCanvas* canvas) | |
217 : PdfTokenLooper(parent, tokenizer, pdfContext, canvas) {} | |
218 | |
219 virtual SkPdfResult consumeToken(PdfToken& token); | |
220 virtual void loop(); | |
221 }; | |
222 | |
223 class PdfInlineImageLooper : public PdfTokenLooper { | |
224 public: | 210 public: |
225 PdfInlineImageLooper() | 211 PdfInlineImageLooper() |
226 : PdfTokenLooper(NULL, NULL, NULL, NULL) {} | 212 : SkPdfTokenLooper(NULL, NULL, NULL, NULL) {} |
227 | 213 |
228 virtual SkPdfResult consumeToken(PdfToken& token); | 214 virtual SkPdfResult consumeToken(PdfToken& token); |
229 virtual void loop(); | 215 virtual void loop(); |
230 SkPdfResult done(); | 216 SkPdfResult done(); |
231 }; | 217 }; |
232 | 218 |
233 class PdfCompatibilitySectionLooper : public PdfTokenLooper { | 219 class PdfCompatibilitySectionLooper : public SkPdfTokenLooper { |
234 public: | 220 public: |
235 PdfCompatibilitySectionLooper() | 221 PdfCompatibilitySectionLooper() |
236 : PdfTokenLooper(NULL, NULL, NULL, NULL) {} | 222 : SkPdfTokenLooper(NULL, NULL, NULL, NULL) {} |
237 | 223 |
238 virtual SkPdfResult consumeToken(PdfToken& token); | 224 virtual SkPdfResult consumeToken(PdfToken& token); |
239 virtual void loop(); | 225 virtual void loop(); |
240 }; | 226 }; |
241 | 227 |
242 // Utilities | 228 // Utilities |
243 static void setup_bitmap(SkBitmap* bitmap, int width, int height, SkColor color
= SK_ColorWHITE) { | 229 static void setup_bitmap(SkBitmap* bitmap, int width, int height, SkColor color
= SK_ColorWHITE) { |
244 bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height); | 230 bitmap->setConfig(SkBitmap::kARGB_8888_Config, width, height); |
245 | 231 |
246 bitmap->allocPixels(); | 232 bitmap->allocPixels(); |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
303 return SkMatrix::I(); | 289 return SkMatrix::I(); |
304 } | 290 } |
305 array[i] = elem->numberValue(); | 291 array[i] = elem->numberValue(); |
306 } | 292 } |
307 | 293 |
308 return SkMatrixFromPdfMatrix(array); | 294 return SkMatrixFromPdfMatrix(array); |
309 } | 295 } |
310 | 296 |
311 // TODO(edisonn): debug code, used to analyze rendering when we find bugs. | 297 // TODO(edisonn): debug code, used to analyze rendering when we find bugs. |
312 extern "C" SkPdfNativeDoc* gDoc; | 298 extern "C" SkPdfNativeDoc* gDoc; |
313 SkBitmap* gDumpBitmap = NULL; | |
314 SkCanvas* gDumpCanvas = NULL; | |
315 char gLastKeyword[100] = ""; | |
316 int gLastOpKeyword = -1; | |
317 int gReadOp = 0; | |
318 | |
319 #ifdef PDF_TRACE_DIFF_IN_PNG | |
320 char allOpWithVisualEffects[100] = ",S,s,f,F,f*,B,B*,b,b*,n,Tj,TJ,\',\",d0,d1,sh
,EI,Do,EX,"; | |
321 static bool hasVisualEffect(const char* pdfOp) { | |
322 return true; | |
323 if (*pdfOp == '\0') return false; | |
324 | |
325 char markedPdfOp[100] = ","; | |
326 strcat(markedPdfOp, pdfOp); | |
327 strcat(markedPdfOp, ","); | |
328 | |
329 return (strstr(allOpWithVisualEffects, markedPdfOp) != NULL); | |
330 } | |
331 #endif // PDF_TRACE_DIFF_IN_PNG | |
332 | |
333 // TODO(edisonn): Pass SkPdfContext and SkCanvasd only with the define for instr
umentation. | |
334 static bool readToken(SkPdfNativeTokenizer* fTokenizer, PdfToken* token) { | |
335 bool ret = fTokenizer->readToken(token); | |
336 | |
337 gReadOp++; | |
338 gLastOpKeyword++; | |
339 #ifdef PDF_TRACE_DIFF_IN_PNG | |
340 // TODO(edisonn): this code is used to make a step by step history of all th
e draw operations | |
341 // so we could find the step where something is wrong. | |
342 if (gLastKeyword[0] && hasVisualEffect(gLastKeyword)) { | |
343 gDumpCanvas->flush(); | |
344 | |
345 SkBitmap bitmap; | |
346 setup_bitmap(&bitmap, gDumpBitmap->width(), gDumpBitmap->height()); | |
347 | |
348 memcpy(bitmap.getPixels(), gDumpBitmap->getPixels(), gDumpBitmap->getSiz
e()); | |
349 | |
350 SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (bitmap))); | |
351 SkCanvas canvas(device); | |
352 | |
353 // draw context stuff here | |
354 SkPaint blueBorder; | |
355 blueBorder.setColor(SK_ColorBLUE); | |
356 blueBorder.setStyle(SkPaint::kStroke_Style); | |
357 blueBorder.setTextSize(SkDoubleToScalar(20)); | |
358 | |
359 SkString str; | |
360 | |
361 const SkClipStack* clipStack = gDumpCanvas->getClipStack(); | |
362 if (clipStack) { | |
363 SkClipStack::Iter iter(*clipStack, SkClipStack::Iter::kBottom_IterSt
art); | |
364 const SkClipStack::Element* elem; | |
365 double y = 0; | |
366 int total = 0; | |
367 while ((elem = iter.next()) != NULL) { | |
368 total++; | |
369 y += 30; | |
370 | |
371 switch (elem->getType()) { | |
372 case SkClipStack::Element::kRect_Type: | |
373 canvas.drawRect(elem->getRect(), blueBorder); | |
374 canvas.drawText("Rect Clip", strlen("Rect Clip"), | |
375 SkDoubleToScalar(10), SkDoubleToScalar(y
), blueBorder); | |
376 break; | |
377 case SkClipStack::Element::kPath_Type: | |
378 canvas.drawPath(elem->getPath(), blueBorder); | |
379 canvas.drawText("Path Clip", strlen("Path Clip"), | |
380 SkDoubleToScalar(10), SkDoubleToScalar(y
), blueBorder); | |
381 break; | |
382 case SkClipStack::Element::kEmpty_Type: | |
383 canvas.drawText("Empty Clip!!!", strlen("Empty Clip!!!")
, | |
384 SkDoubleToScalar(10), SkDoubleToScalar(y
), blueBorder); | |
385 break; | |
386 default: | |
387 canvas.drawText("Unkown Clip!!!", strlen("Unkown Clip!!!
"), | |
388 SkDoubleToScalar(10), SkDoubleToScalar(y
), blueBorder); | |
389 break; | |
390 } | |
391 } | |
392 | |
393 y += 30; | |
394 str.printf("Number of clips in stack: %i", total); | |
395 canvas.drawText(str.c_str(), str.size(), | |
396 SkDoubleToScalar(10), SkDoubleToScalar(y), blueBorde
r); | |
397 } | |
398 | |
399 const SkRegion& clipRegion = gDumpCanvas->getTotalClip(); | |
400 SkPath clipPath; | |
401 if (clipRegion.getBoundaryPath(&clipPath)) { | |
402 SkPaint redBorder; | |
403 redBorder.setColor(SK_ColorRED); | |
404 redBorder.setStyle(SkPaint::kStroke_Style); | |
405 canvas.drawPath(clipPath, redBorder); | |
406 } | |
407 | |
408 canvas.flush(); | |
409 | |
410 SkString out; | |
411 | |
412 // TODO(edisonn): overlay on top of image inf about the clip , grafic st
ate, the stack | |
413 | |
414 out.appendf("/tmp/log_step_by_step/step-%i-%s.png", | |
415 gLastOpKeyword, gLastKeyword); | |
416 SkImageEncoder::EncodeFile(out.c_str(), bitmap, SkImageEncoder::kPNG_Typ
e, 100); | |
417 } | |
418 | |
419 if (ret && token->fType == kKeyword_TokenType && | |
420 token->fKeyword && token->fKeywordLength > 0 && token->fKeywordLengt
h < 100) { | |
421 strncpy(gLastKeyword, token->fKeyword, token->fKeywordLength); | |
422 gLastKeyword[token->fKeywordLength] = '\0'; | |
423 } else { | |
424 gLastKeyword[0] = '\0'; | |
425 } | |
426 #endif | |
427 | |
428 return ret; | |
429 } | |
430 | |
431 // Signature for all the operations available in pdf. | |
432 typedef SkPdfResult (*PdfOperatorRenderer)(SkPdfContext*, SkCanvas*, PdfTokenLoo
per**); | |
433 | |
434 // Map of string to function pointer for all known draw operations. | |
435 SkTDict<PdfOperatorRenderer> gPdfOps(100); | |
436 | |
437 // Temp code to measure what operands fail. | |
438 template <typename T> class SkTDictWithDefaultConstructor : public SkTDict<T> { | |
439 public: | |
440 SkTDictWithDefaultConstructor() : SkTDict<T>(10) {} | |
441 }; | |
442 | |
443 SkTDictWithDefaultConstructor<int> gRenderStats[kCount_SkPdfResult]; | |
444 | |
445 const char* gRenderStatsNames[kCount_SkPdfResult] = { | |
446 "Success", | |
447 "Partially implemented", | |
448 "Not yet implemented", | |
449 "Ignore Error", | |
450 "Error", | |
451 "Unsupported/Unknown" | |
452 }; | |
453 | 299 |
454 static SkPdfResult DrawText(SkPdfContext* pdfContext, | 300 static SkPdfResult DrawText(SkPdfContext* pdfContext, |
455 const SkPdfNativeObject* _str, | 301 const SkPdfNativeObject* _str, |
456 SkCanvas* canvas) | 302 SkCanvas* canvas) |
457 { | 303 { |
458 SkPdfFont* skfont = pdfContext->fGraphicsState.fSkFont; | 304 SkPdfFont* skfont = pdfContext->fGraphicsState.fSkFont; |
459 if (skfont == NULL) { | 305 if (skfont == NULL) { |
460 skfont = SkPdfFont::Default(); | 306 skfont = SkPdfFont::Default(); |
461 } | 307 } |
462 | 308 |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
494 // } | 340 // } |
495 | 341 |
496 pdfContext->fGraphicsState.applyGraphicsState(&paint, false); | 342 pdfContext->fGraphicsState.applyGraphicsState(&paint, false); |
497 | 343 |
498 skfont->drawText(decoded, &paint, pdfContext, canvas); | 344 skfont->drawText(decoded, &paint, pdfContext, canvas); |
499 | 345 |
500 return kOK_SkPdfResult; | 346 return kOK_SkPdfResult; |
501 } | 347 } |
502 | 348 |
503 // TODO(edisonn): create header files with declarations! | 349 // TODO(edisonn): create header files with declarations! |
504 SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper**
looper); | 350 SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper
** looper); |
505 SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper**
looper); | 351 SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper
** looper); |
506 SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper*
* looper); | 352 SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLoope
r** looper); |
507 SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper*
* looper); | 353 SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLoope
r** looper); |
508 | 354 |
509 // TODO(edisonn): perf!!! | 355 // TODO(edisonn): perf!!! |
510 static SkColorTable* getGrayColortable() { | 356 static SkColorTable* getGrayColortable() { |
511 static SkColorTable* grayColortable = NULL; | 357 static SkColorTable* grayColortable = NULL; |
512 if (grayColortable == NULL) { | 358 if (grayColortable == NULL) { |
513 SkPMColor* colors = new SkPMColor[256]; | 359 SkPMColor* colors = new SkPMColor[256]; |
514 for (int i = 0 ; i < 256; i++) { | 360 for (int i = 0 ; i < 256; i++) { |
515 colors[i] = SkPreMultiplyARGB(255, i, i, i); | 361 colors[i] = SkPreMultiplyARGB(255, i, i, i); |
516 } | 362 } |
517 grayColortable = new SkColorTable(colors, 256); | 363 grayColortable = new SkColorTable(colors, 256); |
(...skipping 341 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
859 canvas->clipRect(bbox, SkRegion::kIntersect_Op, false); | 705 canvas->clipRect(bbox, SkRegion::kIntersect_Op, false); |
860 | 706 |
861 // This is a group? | 707 // This is a group? |
862 if (skobj->has_Group()) { | 708 if (skobj->has_Group()) { |
863 SkPdfTransparencyGroupDictionary* tgroup = skobj->Group(pdfContext->fPdf
Doc); | 709 SkPdfTransparencyGroupDictionary* tgroup = skobj->Group(pdfContext->fPdf
Doc); |
864 doGroup_before(pdfContext, canvas, bbox, tgroup, false); | 710 doGroup_before(pdfContext, canvas, bbox, tgroup, false); |
865 } | 711 } |
866 | 712 |
867 SkPdfStream* stream = (SkPdfStream*)skobj; | 713 SkPdfStream* stream = (SkPdfStream*)skobj; |
868 | 714 |
869 SkPdfNativeTokenizer* tokenizer = | 715 pdfContext->parseStream(stream, canvas); |
870 pdfContext->fPdfDoc->tokenizerOfStream(stream, pdfContext->fTmpPageA
llocator); | |
871 if (tokenizer != NULL) { | |
872 PdfMainLooper looper(NULL, tokenizer, pdfContext, canvas); | |
873 looper.loop(); | |
874 delete tokenizer; | |
875 } | |
876 | 716 |
877 if (skobj->has_Group()) { | 717 if (skobj->has_Group()) { |
878 canvas->restore(); | 718 canvas->restore(); |
879 } | 719 } |
880 | 720 |
881 PdfOp_Q(pdfContext, canvas, NULL); | 721 PdfOp_Q(pdfContext, canvas, NULL); |
882 return kPartial_SkPdfResult; | 722 return kPartial_SkPdfResult; |
883 } | 723 } |
884 | 724 |
885 static SkPdfResult doXObject_Pattern(SkPdfContext* pdfContext, SkCanvas* canvas, | 725 static SkPdfResult doXObject_Pattern(SkPdfContext* pdfContext, SkCanvas* canvas, |
(...skipping 28 matching lines...) Expand all Loading... |
914 | 754 |
915 canvas->setMatrix(pdfContext->fGraphicsState.fContentStreamMatrix); | 755 canvas->setMatrix(pdfContext->fGraphicsState.fContentStreamMatrix); |
916 pdfContext->fGraphicsState.fCTM = pdfContext->fGraphicsState.fContentStreamM
atrix; | 756 pdfContext->fGraphicsState.fCTM = pdfContext->fGraphicsState.fContentStreamM
atrix; |
917 | 757 |
918 SkRect bbox = skobj->BBox(pdfContext->fPdfDoc); | 758 SkRect bbox = skobj->BBox(pdfContext->fPdfDoc); |
919 // TODO(edisonn): constants (AA) from settings. | 759 // TODO(edisonn): constants (AA) from settings. |
920 canvas->clipRect(bbox, SkRegion::kIntersect_Op, false); | 760 canvas->clipRect(bbox, SkRegion::kIntersect_Op, false); |
921 | 761 |
922 SkPdfStream* stream = (SkPdfStream*)skobj; | 762 SkPdfStream* stream = (SkPdfStream*)skobj; |
923 | 763 |
924 SkPdfNativeTokenizer* tokenizer = | 764 pdfContext->parseStream(stream, canvas); |
925 pdfContext->fPdfDoc->tokenizerOfStream(stream, pdfContext->fTmpPageA
llocator); | |
926 if (tokenizer != NULL) { | |
927 PdfMainLooper looper(NULL, tokenizer, pdfContext, canvas); | |
928 looper.loop(); | |
929 delete tokenizer; | |
930 } | |
931 | 765 |
932 PdfOp_Q(pdfContext, canvas, NULL); | 766 PdfOp_Q(pdfContext, canvas, NULL); |
933 return kPartial_SkPdfResult; | 767 return kPartial_SkPdfResult; |
934 } | 768 } |
935 | 769 |
936 // TODO(edisonn): PS NYI | 770 // TODO(edisonn): PS NYI |
937 //static SkPdfResult doXObject_PS(SkPdfContext* pdfContext, SkCanvas* canvas, | 771 //static SkPdfResult doXObject_PS(SkPdfContext* pdfContext, SkCanvas* canvas, |
938 // const SkPdfNativeObject* obj) { | 772 // const SkPdfNativeObject* obj) { |
939 // return kNYI_SkPdfResult; | 773 // return kNYI_SkPdfResult; |
940 //} | 774 //} |
(...skipping 23 matching lines...) Expand all Loading... |
964 SkRect rm = bBox; | 798 SkRect rm = bBox; |
965 pdfContext->fGraphicsState.fCTM.mapRect(&rm); | 799 pdfContext->fGraphicsState.fCTM.mapRect(&rm); |
966 | 800 |
967 SkTraceRect(rm, "bbox mapped"); | 801 SkTraceRect(rm, "bbox mapped"); |
968 | 802 |
969 // TODO(edisonn): constants (AA) from settings. | 803 // TODO(edisonn): constants (AA) from settings. |
970 canvas->clipRect(bBox, SkRegion::kIntersect_Op, false); | 804 canvas->clipRect(bBox, SkRegion::kIntersect_Op, false); |
971 | 805 |
972 SkPdfStream* stream = (SkPdfStream*)skobj; | 806 SkPdfStream* stream = (SkPdfStream*)skobj; |
973 | 807 |
974 SkPdfNativeTokenizer* tokenizer = | 808 pdfContext->parseStream(stream, canvas); |
975 pdfContext->fPdfDoc->tokenizerOfStream(stream, pdfContext->fTmpPageA
llocator); | |
976 if (tokenizer != NULL) { | |
977 PdfMainLooper looper(NULL, tokenizer, pdfContext, canvas); | |
978 looper.loop(); | |
979 delete tokenizer; | |
980 } | |
981 | 809 |
982 PdfOp_Q(pdfContext, canvas, NULL); | 810 PdfOp_Q(pdfContext, canvas, NULL); |
983 | 811 |
984 return kPartial_SkPdfResult; | 812 return kPartial_SkPdfResult; |
985 } | 813 } |
986 | 814 |
987 // The PDF could be corrupted so a dict refers recursively to the same dict, if
this happens | 815 // The PDF could be corrupted so a dict refers recursively to the same dict, if
this happens |
988 // we end up with a stack overflow and crash. | 816 // we end up with a stack overflow and crash. |
989 class CheckRecursiveRendering { | 817 class CheckRecursiveRendering { |
990 SkPdfNativeObject* fObj; | 818 SkPdfNativeObject* fObj; |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1073 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "MediaBox inhe
ritance NYI", | 901 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "MediaBox inhe
ritance NYI", |
1074 NULL, pdfContext); | 902 NULL, pdfContext); |
1075 SkRect bbox = skobj->MediaBox(pdfContext->fPdfDoc); | 903 SkRect bbox = skobj->MediaBox(pdfContext->fPdfDoc); |
1076 if (skobj->has_Group()) { | 904 if (skobj->has_Group()) { |
1077 SkPdfTransparencyGroupDictionary* tgroup = skobj->Group(pdfContext->fPdf
Doc); | 905 SkPdfTransparencyGroupDictionary* tgroup = skobj->Group(pdfContext->fPdf
Doc); |
1078 doGroup_before(pdfContext, canvas, bbox, tgroup, true); | 906 doGroup_before(pdfContext, canvas, bbox, tgroup, true); |
1079 } else { | 907 } else { |
1080 canvas->save(); | 908 canvas->save(); |
1081 } | 909 } |
1082 | 910 |
1083 | 911 pdfContext->parseStream(stream, canvas); |
1084 SkPdfNativeTokenizer* tokenizer = | |
1085 pdfContext->fPdfDoc->tokenizerOfStream(stream, pdfContext->fTmpPageA
llocator); | |
1086 if (tokenizer != NULL) { | |
1087 PdfMainLooper looper(NULL, tokenizer, pdfContext, canvas); | |
1088 looper.loop(); | |
1089 delete tokenizer; | |
1090 } | |
1091 | 912 |
1092 canvas->restore(); | 913 canvas->restore(); |
1093 PdfOp_Q(pdfContext, canvas, NULL); | 914 PdfOp_Q(pdfContext, canvas, NULL); |
1094 return kPartial_SkPdfResult; | 915 return kPartial_SkPdfResult; |
1095 } | 916 } |
1096 | 917 |
1097 SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper**
looper) { | 918 SkPdfResult PdfOp_q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper
** looper) { |
1098 pdfContext->fStateStack.push(pdfContext->fGraphicsState); | 919 pdfContext->fStateStack.push(pdfContext->fGraphicsState); |
1099 canvas->save(); | 920 canvas->save(); |
1100 pdfContext->fObjectStack.nest(); | 921 pdfContext->fObjectStack.nest(); |
1101 return kOK_SkPdfResult; | 922 return kOK_SkPdfResult; |
1102 } | 923 } |
1103 | 924 |
1104 SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper**
looper) { | 925 SkPdfResult PdfOp_Q(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLooper
** looper) { |
1105 if (pdfContext->fStateStack.count() > 0) { | 926 if (pdfContext->fStateStack.count() > 0) { |
1106 pdfContext->fGraphicsState = pdfContext->fStateStack.top(); | 927 pdfContext->fGraphicsState = pdfContext->fStateStack.top(); |
1107 pdfContext->fStateStack.pop(); | 928 pdfContext->fStateStack.pop(); |
1108 canvas->restore(); | 929 canvas->restore(); |
1109 | 930 |
1110 if (pdfContext->fObjectStack.nestingLevel() == 0) { | 931 if (pdfContext->fObjectStack.nestingLevel() == 0) { |
1111 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kStackNestingOverflow_S
kPdfIssue, | 932 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kStackNestingOverflow_S
kPdfIssue, |
1112 "stack nesting overflow (q/Q)", NULL, pdfContext); | 933 "stack nesting overflow (q/Q)", NULL, pdfContext); |
1113 return kIgnoreError_SkPdfResult; | 934 return kIgnoreError_SkPdfResult; |
1114 } else { | 935 } else { |
1115 pdfContext->fObjectStack.unnest(); | 936 pdfContext->fObjectStack.unnest(); |
1116 } | 937 } |
1117 } else { | 938 } else { |
1118 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kStackOverflow_SkPdfIssue, | 939 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kStackOverflow_SkPdfIssue, |
1119 "stack overflow (q/Q)", NULL, pdfContext); | 940 "stack overflow (q/Q)", NULL, pdfContext); |
1120 return kIgnoreError_SkPdfResult; | 941 return kIgnoreError_SkPdfResult; |
1121 } | 942 } |
1122 | 943 |
1123 return kOK_SkPdfResult; | 944 return kOK_SkPdfResult; |
1124 } | 945 } |
1125 | 946 |
1126 static SkPdfResult PdfOp_cm(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 947 static SkPdfResult PdfOp_cm(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1127 EXPECT_OPERANDS("cm", pdfContext, 6); | 948 EXPECT_OPERANDS("cm", pdfContext, 6); |
1128 POP_NUMBER(pdfContext, f); | 949 POP_NUMBER(pdfContext, f); |
1129 POP_NUMBER(pdfContext, e); | 950 POP_NUMBER(pdfContext, e); |
1130 POP_NUMBER(pdfContext, d); | 951 POP_NUMBER(pdfContext, d); |
1131 POP_NUMBER(pdfContext, c); | 952 POP_NUMBER(pdfContext, c); |
1132 POP_NUMBER(pdfContext, b); | 953 POP_NUMBER(pdfContext, b); |
1133 POP_NUMBER(pdfContext, a); | 954 POP_NUMBER(pdfContext, a); |
1134 CHECK_PARAMETERS(); | 955 CHECK_PARAMETERS(); |
1135 double array[6] = {a, b, c, d, e, f}; | 956 double array[6] = {a, b, c, d, e, f}; |
1136 | 957 |
(...skipping 20 matching lines...) Expand all Loading... |
1157 printf("\n"); | 978 printf("\n"); |
1158 SkTraceMatrix(pdfContext->fGraphicsState.fCTM, "cm"); | 979 SkTraceMatrix(pdfContext->fGraphicsState.fCTM, "cm"); |
1159 #endif | 980 #endif |
1160 | 981 |
1161 return kOK_SkPdfResult; | 982 return kOK_SkPdfResult; |
1162 } | 983 } |
1163 | 984 |
1164 //leading TL Set the text leading, Tl | 985 //leading TL Set the text leading, Tl |
1165 //, to leading, which is a number expressed in unscaled text | 986 //, to leading, which is a number expressed in unscaled text |
1166 //space units. Text leading is used only by the T*, ', and " operators. Initial
value: 0. | 987 //space units. Text leading is used only by the T*, ', and " operators. Initial
value: 0. |
1167 static SkPdfResult PdfOp_TL(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 988 static SkPdfResult PdfOp_TL(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1168 EXPECT_OPERANDS("TL", pdfContext, 1); | 989 EXPECT_OPERANDS("TL", pdfContext, 1); |
1169 POP_NUMBER(pdfContext, ty); | 990 POP_NUMBER(pdfContext, ty); |
1170 CHECK_PARAMETERS(); | 991 CHECK_PARAMETERS(); |
1171 | 992 |
1172 pdfContext->fGraphicsState.fTextLeading = ty; | 993 pdfContext->fGraphicsState.fTextLeading = ty; |
1173 | 994 |
1174 return kOK_SkPdfResult; | 995 return kOK_SkPdfResult; |
1175 } | 996 } |
1176 | 997 |
1177 static SkPdfResult PdfOp_Td(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 998 static SkPdfResult PdfOp_Td(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1178 EXPECT_OPERANDS("Td", pdfContext, 2); | 999 EXPECT_OPERANDS("Td", pdfContext, 2); |
1179 POP_NUMBER(pdfContext, ty); | 1000 POP_NUMBER(pdfContext, ty); |
1180 POP_NUMBER(pdfContext, tx); | 1001 POP_NUMBER(pdfContext, tx); |
1181 CHECK_PARAMETERS(); | 1002 CHECK_PARAMETERS(); |
1182 | 1003 |
1183 double array[6] = {1, 0, 0, 1, tx, -ty}; | 1004 double array[6] = {1, 0, 0, 1, tx, -ty}; |
1184 SkMatrix matrix = SkMatrixFromPdfMatrix(array); | 1005 SkMatrix matrix = SkMatrixFromPdfMatrix(array); |
1185 | 1006 |
1186 pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix); | 1007 pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix); |
1187 pdfContext->fGraphicsState.fMatrixTlm.preConcat(matrix); | 1008 pdfContext->fGraphicsState.fMatrixTlm.preConcat(matrix); |
1188 | 1009 |
1189 return kPartial_SkPdfResult; | 1010 return kPartial_SkPdfResult; |
1190 } | 1011 } |
1191 | 1012 |
1192 static SkPdfResult PdfOp_TD(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1013 static SkPdfResult PdfOp_TD(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1193 EXPECT_OPERANDS("TD", pdfContext, 2) | 1014 EXPECT_OPERANDS("TD", pdfContext, 2) |
1194 POP_NUMBER(pdfContext, ty); | 1015 POP_NUMBER(pdfContext, ty); |
1195 POP_NUMBER(pdfContext, tx); | 1016 POP_NUMBER(pdfContext, tx); |
1196 CHECK_PARAMETERS(); | 1017 CHECK_PARAMETERS(); |
1197 | 1018 |
1198 // TODO(edisonn): Create factory methods or constructors so native is hidden | 1019 // TODO(edisonn): Create factory methods or constructors so native is hidden |
1199 SkPdfReal* _ty = pdfContext->fPdfDoc->createReal(-ty); | 1020 SkPdfReal* _ty = pdfContext->fPdfDoc->createReal(-ty); |
1200 pdfContext->fObjectStack.push(_ty); | 1021 pdfContext->fObjectStack.push(_ty); |
1201 | 1022 |
1202 PdfOp_TL(pdfContext, canvas, looper); | 1023 PdfOp_TL(pdfContext, canvas, looper); |
1203 | 1024 |
1204 SkPdfReal* vtx = pdfContext->fPdfDoc->createReal(tx); | 1025 SkPdfReal* vtx = pdfContext->fPdfDoc->createReal(tx); |
1205 pdfContext->fObjectStack.push(vtx); | 1026 pdfContext->fObjectStack.push(vtx); |
1206 | 1027 |
1207 SkPdfReal* vty = pdfContext->fPdfDoc->createReal(ty); | 1028 SkPdfReal* vty = pdfContext->fPdfDoc->createReal(ty); |
1208 pdfContext->fObjectStack.push(vty); | 1029 pdfContext->fObjectStack.push(vty); |
1209 | 1030 |
1210 SkPdfResult ret = PdfOp_Td(pdfContext, canvas, looper); | 1031 SkPdfResult ret = PdfOp_Td(pdfContext, canvas, looper); |
1211 | 1032 |
1212 return ret; | 1033 return ret; |
1213 } | 1034 } |
1214 | 1035 |
1215 static SkPdfResult PdfOp_Tm(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1036 static SkPdfResult PdfOp_Tm(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1216 EXPECT_OPERANDS("Tm", pdfContext, 6); | 1037 EXPECT_OPERANDS("Tm", pdfContext, 6); |
1217 POP_NUMBER(pdfContext, f); | 1038 POP_NUMBER(pdfContext, f); |
1218 POP_NUMBER(pdfContext, e); | 1039 POP_NUMBER(pdfContext, e); |
1219 POP_NUMBER(pdfContext, d); | 1040 POP_NUMBER(pdfContext, d); |
1220 POP_NUMBER(pdfContext, c); | 1041 POP_NUMBER(pdfContext, c); |
1221 POP_NUMBER(pdfContext, b); | 1042 POP_NUMBER(pdfContext, b); |
1222 POP_NUMBER(pdfContext, a); | 1043 POP_NUMBER(pdfContext, a); |
1223 CHECK_PARAMETERS(); | 1044 CHECK_PARAMETERS(); |
1224 | 1045 |
1225 double array[6]; | 1046 double array[6]; |
(...skipping 15 matching lines...) Expand all Loading... |
1241 pdfContext->fGraphicsState.fMatrixTm = matrix; | 1062 pdfContext->fGraphicsState.fMatrixTm = matrix; |
1242 pdfContext->fGraphicsState.fMatrixTlm = matrix;; | 1063 pdfContext->fGraphicsState.fMatrixTlm = matrix;; |
1243 | 1064 |
1244 return kPartial_SkPdfResult; | 1065 return kPartial_SkPdfResult; |
1245 } | 1066 } |
1246 | 1067 |
1247 //— T* Move to the start of the next line. This operator has the same effect as
the code | 1068 //— T* Move to the start of the next line. This operator has the same effect as
the code |
1248 //0 Tl Td | 1069 //0 Tl Td |
1249 //where Tl is the current leading parameter in the text state | 1070 //where Tl is the current leading parameter in the text state |
1250 static SkPdfResult PdfOp_T_star(SkPdfContext* pdfContext, SkCanvas* canvas, | 1071 static SkPdfResult PdfOp_T_star(SkPdfContext* pdfContext, SkCanvas* canvas, |
1251 PdfTokenLooper** looper) { | 1072 SkPdfTokenLooper** looper) { |
1252 SkPdfReal* zero = pdfContext->fPdfDoc->createReal(0.0); | 1073 SkPdfReal* zero = pdfContext->fPdfDoc->createReal(0.0); |
1253 SkPdfReal* tl = pdfContext->fPdfDoc->createReal(pdfContext->fGraphicsState.f
TextLeading); | 1074 SkPdfReal* tl = pdfContext->fPdfDoc->createReal(pdfContext->fGraphicsState.f
TextLeading); |
1254 | 1075 |
1255 pdfContext->fObjectStack.push(zero); | 1076 pdfContext->fObjectStack.push(zero); |
1256 pdfContext->fObjectStack.push(tl); | 1077 pdfContext->fObjectStack.push(tl); |
1257 | 1078 |
1258 SkPdfResult ret = PdfOp_Td(pdfContext, canvas, looper); | 1079 SkPdfResult ret = PdfOp_Td(pdfContext, canvas, looper); |
1259 | 1080 |
1260 return ret; | 1081 return ret; |
1261 } | 1082 } |
1262 | 1083 |
1263 static SkPdfResult PdfOp_m(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1084 static SkPdfResult PdfOp_m(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1264 if (pdfContext->fGraphicsState.fPathClosed) { | 1085 if (pdfContext->fGraphicsState.fPathClosed) { |
1265 pdfContext->fGraphicsState.fPath.reset(); | 1086 pdfContext->fGraphicsState.fPath.reset(); |
1266 pdfContext->fGraphicsState.fPathClosed = false; | 1087 pdfContext->fGraphicsState.fPathClosed = false; |
1267 } | 1088 } |
1268 | 1089 |
1269 EXPECT_OPERANDS("m", pdfContext, 2); | 1090 EXPECT_OPERANDS("m", pdfContext, 2); |
1270 POP_NUMBER(pdfContext, y); | 1091 POP_NUMBER(pdfContext, y); |
1271 POP_NUMBER(pdfContext, x); | 1092 POP_NUMBER(pdfContext, x); |
1272 CHECK_PARAMETERS(); | 1093 CHECK_PARAMETERS(); |
1273 | 1094 |
1274 pdfContext->fGraphicsState.fCurPosY = y; | 1095 pdfContext->fGraphicsState.fCurPosY = y; |
1275 pdfContext->fGraphicsState.fCurPosX = x; | 1096 pdfContext->fGraphicsState.fCurPosX = x; |
1276 | 1097 |
1277 pdfContext->fGraphicsState.fPath.moveTo(SkDoubleToScalar(pdfContext->fGraphi
csState.fCurPosX), | 1098 pdfContext->fGraphicsState.fPath.moveTo(SkDoubleToScalar(pdfContext->fGraphi
csState.fCurPosX), |
1278 SkDoubleToScalar(pdfContext->fGraphi
csState.fCurPosY)); | 1099 SkDoubleToScalar(pdfContext->fGraphi
csState.fCurPosY)); |
1279 | 1100 |
1280 return kOK_SkPdfResult; | 1101 return kOK_SkPdfResult; |
1281 } | 1102 } |
1282 | 1103 |
1283 static SkPdfResult PdfOp_l(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1104 static SkPdfResult PdfOp_l(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1284 if (pdfContext->fGraphicsState.fPathClosed) { | 1105 if (pdfContext->fGraphicsState.fPathClosed) { |
1285 pdfContext->fGraphicsState.fPath.reset(); | 1106 pdfContext->fGraphicsState.fPath.reset(); |
1286 pdfContext->fGraphicsState.fPathClosed = false; | 1107 pdfContext->fGraphicsState.fPathClosed = false; |
1287 } | 1108 } |
1288 | 1109 |
1289 EXPECT_OPERANDS("l", pdfContext, 2); | 1110 EXPECT_OPERANDS("l", pdfContext, 2); |
1290 POP_NUMBER(pdfContext, y); | 1111 POP_NUMBER(pdfContext, y); |
1291 POP_NUMBER(pdfContext, x); | 1112 POP_NUMBER(pdfContext, x); |
1292 CHECK_PARAMETERS(); | 1113 CHECK_PARAMETERS(); |
1293 | 1114 |
1294 pdfContext->fGraphicsState.fCurPosY = y; | 1115 pdfContext->fGraphicsState.fCurPosY = y; |
1295 pdfContext->fGraphicsState.fCurPosX = x; | 1116 pdfContext->fGraphicsState.fCurPosX = x; |
1296 | 1117 |
1297 pdfContext->fGraphicsState.fPath.lineTo(SkDoubleToScalar(pdfContext->fGraphi
csState.fCurPosX), | 1118 pdfContext->fGraphicsState.fPath.lineTo(SkDoubleToScalar(pdfContext->fGraphi
csState.fCurPosX), |
1298 SkDoubleToScalar(pdfContext->fGraphi
csState.fCurPosY)); | 1119 SkDoubleToScalar(pdfContext->fGraphi
csState.fCurPosY)); |
1299 | 1120 |
1300 return kOK_SkPdfResult; | 1121 return kOK_SkPdfResult; |
1301 } | 1122 } |
1302 | 1123 |
1303 static SkPdfResult PdfOp_c(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1124 static SkPdfResult PdfOp_c(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1304 if (pdfContext->fGraphicsState.fPathClosed) { | 1125 if (pdfContext->fGraphicsState.fPathClosed) { |
1305 pdfContext->fGraphicsState.fPath.reset(); | 1126 pdfContext->fGraphicsState.fPath.reset(); |
1306 pdfContext->fGraphicsState.fPathClosed = false; | 1127 pdfContext->fGraphicsState.fPathClosed = false; |
1307 } | 1128 } |
1308 | 1129 |
1309 EXPECT_OPERANDS("c", pdfContext, 6); | 1130 EXPECT_OPERANDS("c", pdfContext, 6); |
1310 POP_NUMBER(pdfContext, y3); | 1131 POP_NUMBER(pdfContext, y3); |
1311 POP_NUMBER(pdfContext, x3); | 1132 POP_NUMBER(pdfContext, x3); |
1312 POP_NUMBER(pdfContext, y2); | 1133 POP_NUMBER(pdfContext, y2); |
1313 POP_NUMBER(pdfContext, x2); | 1134 POP_NUMBER(pdfContext, x2); |
1314 POP_NUMBER(pdfContext, y1); | 1135 POP_NUMBER(pdfContext, y1); |
1315 POP_NUMBER(pdfContext, x1); | 1136 POP_NUMBER(pdfContext, x1); |
1316 CHECK_PARAMETERS(); | 1137 CHECK_PARAMETERS(); |
1317 | 1138 |
1318 pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToSca
lar(y1), | 1139 pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToSca
lar(y1), |
1319 SkDoubleToScalar(x2), SkDoubleToSca
lar(y2), | 1140 SkDoubleToScalar(x2), SkDoubleToSca
lar(y2), |
1320 SkDoubleToScalar(x3), SkDoubleToSca
lar(y3)); | 1141 SkDoubleToScalar(x3), SkDoubleToSca
lar(y3)); |
1321 | 1142 |
1322 pdfContext->fGraphicsState.fCurPosX = x3; | 1143 pdfContext->fGraphicsState.fCurPosX = x3; |
1323 pdfContext->fGraphicsState.fCurPosY = y3; | 1144 pdfContext->fGraphicsState.fCurPosY = y3; |
1324 | 1145 |
1325 return kOK_SkPdfResult; | 1146 return kOK_SkPdfResult; |
1326 } | 1147 } |
1327 | 1148 |
1328 static SkPdfResult PdfOp_v(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1149 static SkPdfResult PdfOp_v(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1329 if (pdfContext->fGraphicsState.fPathClosed) { | 1150 if (pdfContext->fGraphicsState.fPathClosed) { |
1330 pdfContext->fGraphicsState.fPath.reset(); | 1151 pdfContext->fGraphicsState.fPath.reset(); |
1331 pdfContext->fGraphicsState.fPathClosed = false; | 1152 pdfContext->fGraphicsState.fPathClosed = false; |
1332 } | 1153 } |
1333 | 1154 |
1334 EXPECT_OPERANDS("v", pdfContext, 4); | 1155 EXPECT_OPERANDS("v", pdfContext, 4); |
1335 POP_NUMBER(pdfContext, y3); | 1156 POP_NUMBER(pdfContext, y3); |
1336 POP_NUMBER(pdfContext, x3); | 1157 POP_NUMBER(pdfContext, x3); |
1337 POP_NUMBER(pdfContext, y2); | 1158 POP_NUMBER(pdfContext, y2); |
1338 POP_NUMBER(pdfContext, x2); | 1159 POP_NUMBER(pdfContext, x2); |
1339 CHECK_PARAMETERS(); | 1160 CHECK_PARAMETERS(); |
1340 | 1161 |
1341 double y1 = pdfContext->fGraphicsState.fCurPosY; | 1162 double y1 = pdfContext->fGraphicsState.fCurPosY; |
1342 double x1 = pdfContext->fGraphicsState.fCurPosX; | 1163 double x1 = pdfContext->fGraphicsState.fCurPosX; |
1343 | 1164 |
1344 pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToSca
lar(y1), | 1165 pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToSca
lar(y1), |
1345 SkDoubleToScalar(x2), SkDoubleToSca
lar(y2), | 1166 SkDoubleToScalar(x2), SkDoubleToSca
lar(y2), |
1346 SkDoubleToScalar(x3), SkDoubleToSca
lar(y3)); | 1167 SkDoubleToScalar(x3), SkDoubleToSca
lar(y3)); |
1347 | 1168 |
1348 pdfContext->fGraphicsState.fCurPosX = x3; | 1169 pdfContext->fGraphicsState.fCurPosX = x3; |
1349 pdfContext->fGraphicsState.fCurPosY = y3; | 1170 pdfContext->fGraphicsState.fCurPosY = y3; |
1350 | 1171 |
1351 return kOK_SkPdfResult; | 1172 return kOK_SkPdfResult; |
1352 } | 1173 } |
1353 | 1174 |
1354 static SkPdfResult PdfOp_y(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1175 static SkPdfResult PdfOp_y(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1355 if (pdfContext->fGraphicsState.fPathClosed) { | 1176 if (pdfContext->fGraphicsState.fPathClosed) { |
1356 pdfContext->fGraphicsState.fPath.reset(); | 1177 pdfContext->fGraphicsState.fPath.reset(); |
1357 pdfContext->fGraphicsState.fPathClosed = false; | 1178 pdfContext->fGraphicsState.fPathClosed = false; |
1358 } | 1179 } |
1359 | 1180 |
1360 EXPECT_OPERANDS("y", pdfContext, 4); | 1181 EXPECT_OPERANDS("y", pdfContext, 4); |
1361 POP_NUMBER(pdfContext, y3); | 1182 POP_NUMBER(pdfContext, y3); |
1362 POP_NUMBER(pdfContext, x3); | 1183 POP_NUMBER(pdfContext, x3); |
1363 POP_NUMBER(pdfContext, y1); | 1184 POP_NUMBER(pdfContext, y1); |
1364 POP_NUMBER(pdfContext, x1); | 1185 POP_NUMBER(pdfContext, x1); |
1365 CHECK_PARAMETERS(); | 1186 CHECK_PARAMETERS(); |
1366 | 1187 |
1367 double y2 = pdfContext->fGraphicsState.fCurPosY; | 1188 double y2 = pdfContext->fGraphicsState.fCurPosY; |
1368 double x2 = pdfContext->fGraphicsState.fCurPosX; | 1189 double x2 = pdfContext->fGraphicsState.fCurPosX; |
1369 | 1190 |
1370 pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToSca
lar(y1), | 1191 pdfContext->fGraphicsState.fPath.cubicTo(SkDoubleToScalar(x1), SkDoubleToSca
lar(y1), |
1371 SkDoubleToScalar(x2), SkDoubleToSca
lar(y2), | 1192 SkDoubleToScalar(x2), SkDoubleToSca
lar(y2), |
1372 SkDoubleToScalar(x3), SkDoubleToSca
lar(y3)); | 1193 SkDoubleToScalar(x3), SkDoubleToSca
lar(y3)); |
1373 | 1194 |
1374 pdfContext->fGraphicsState.fCurPosX = x3; | 1195 pdfContext->fGraphicsState.fCurPosX = x3; |
1375 pdfContext->fGraphicsState.fCurPosY = y3; | 1196 pdfContext->fGraphicsState.fCurPosY = y3; |
1376 | 1197 |
1377 return kOK_SkPdfResult; | 1198 return kOK_SkPdfResult; |
1378 } | 1199 } |
1379 | 1200 |
1380 static SkPdfResult PdfOp_re(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1201 static SkPdfResult PdfOp_re(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1381 if (pdfContext->fGraphicsState.fPathClosed) { | 1202 if (pdfContext->fGraphicsState.fPathClosed) { |
1382 pdfContext->fGraphicsState.fPath.reset(); | 1203 pdfContext->fGraphicsState.fPath.reset(); |
1383 pdfContext->fGraphicsState.fPathClosed = false; | 1204 pdfContext->fGraphicsState.fPathClosed = false; |
1384 } | 1205 } |
1385 | 1206 |
1386 EXPECT_OPERANDS("re", pdfContext, 4); | 1207 EXPECT_OPERANDS("re", pdfContext, 4); |
1387 POP_NUMBER(pdfContext, height); | 1208 POP_NUMBER(pdfContext, height); |
1388 POP_NUMBER(pdfContext, width); | 1209 POP_NUMBER(pdfContext, width); |
1389 POP_NUMBER(pdfContext, y); | 1210 POP_NUMBER(pdfContext, y); |
1390 POP_NUMBER(pdfContext, x); | 1211 POP_NUMBER(pdfContext, x); |
1391 CHECK_PARAMETERS(); | 1212 CHECK_PARAMETERS(); |
1392 | 1213 |
1393 pdfContext->fGraphicsState.fPath.addRect(SkDoubleToScalar(x), | 1214 pdfContext->fGraphicsState.fPath.addRect(SkDoubleToScalar(x), |
1394 SkDoubleToScalar(y), | 1215 SkDoubleToScalar(y), |
1395 SkDoubleToScalar(x + width), | 1216 SkDoubleToScalar(x + width), |
1396 SkDoubleToScalar(y + height)); | 1217 SkDoubleToScalar(y + height)); |
1397 | 1218 |
1398 pdfContext->fGraphicsState.fCurPosX = x; | 1219 pdfContext->fGraphicsState.fCurPosX = x; |
1399 pdfContext->fGraphicsState.fCurPosY = y + height; | 1220 pdfContext->fGraphicsState.fCurPosY = y + height; |
1400 | 1221 |
1401 return kOK_SkPdfResult; | 1222 return kOK_SkPdfResult; |
1402 } | 1223 } |
1403 | 1224 |
1404 static SkPdfResult PdfOp_h(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1225 static SkPdfResult PdfOp_h(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1405 pdfContext->fGraphicsState.fPath.close(); | 1226 pdfContext->fGraphicsState.fPath.close(); |
1406 return kOK_SkPdfResult; | 1227 return kOK_SkPdfResult; |
1407 } | 1228 } |
1408 | 1229 |
1409 static SkPdfResult PdfOp_fillAndStroke(SkPdfContext* pdfContext, SkCanvas* canva
s, | 1230 static SkPdfResult PdfOp_fillAndStroke(SkPdfContext* pdfContext, SkCanvas* canva
s, |
1410 bool fill, bool stroke, bool close, bool
evenOdd) { | 1231 bool fill, bool stroke, bool close, bool
evenOdd) { |
1411 SkPath path = pdfContext->fGraphicsState.fPath; | 1232 SkPath path = pdfContext->fGraphicsState.fPath; |
1412 | 1233 |
1413 if (close) { | 1234 if (close) { |
1414 path.close(); | 1235 path.close(); |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1544 #endif | 1365 #endif |
1545 } | 1366 } |
1546 | 1367 |
1547 //pdfContext->fGraphicsState.fClipPath.reset(); | 1368 //pdfContext->fGraphicsState.fClipPath.reset(); |
1548 pdfContext->fGraphicsState.fHasClipPathToApply = false; | 1369 pdfContext->fGraphicsState.fHasClipPathToApply = false; |
1549 | 1370 |
1550 return kOK_SkPdfResult; | 1371 return kOK_SkPdfResult; |
1551 | 1372 |
1552 } | 1373 } |
1553 | 1374 |
1554 static SkPdfResult PdfOp_S(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1375 static SkPdfResult PdfOp_S(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1555 return PdfOp_fillAndStroke(pdfContext, canvas, false, true, false, false); | 1376 return PdfOp_fillAndStroke(pdfContext, canvas, false, true, false, false); |
1556 } | 1377 } |
1557 | 1378 |
1558 static SkPdfResult PdfOp_s(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1379 static SkPdfResult PdfOp_s(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1559 return PdfOp_fillAndStroke(pdfContext, canvas, false, true, true, false); | 1380 return PdfOp_fillAndStroke(pdfContext, canvas, false, true, true, false); |
1560 } | 1381 } |
1561 | 1382 |
1562 static SkPdfResult PdfOp_F(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1383 static SkPdfResult PdfOp_F(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1563 return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false); | 1384 return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false); |
1564 } | 1385 } |
1565 | 1386 |
1566 static SkPdfResult PdfOp_f(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1387 static SkPdfResult PdfOp_f(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1567 return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false); | 1388 return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, false); |
1568 } | 1389 } |
1569 | 1390 |
1570 static SkPdfResult PdfOp_f_star(SkPdfContext* pdfContext, SkCanvas* canvas, | 1391 static SkPdfResult PdfOp_f_star(SkPdfContext* pdfContext, SkCanvas* canvas, |
1571 PdfTokenLooper** looper) { | 1392 SkPdfTokenLooper** looper) { |
1572 return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, true); | 1393 return PdfOp_fillAndStroke(pdfContext, canvas, true, false, false, true); |
1573 } | 1394 } |
1574 | 1395 |
1575 static SkPdfResult PdfOp_B(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1396 static SkPdfResult PdfOp_B(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1576 return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, false); | 1397 return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, false); |
1577 } | 1398 } |
1578 | 1399 |
1579 static SkPdfResult PdfOp_B_star(SkPdfContext* pdfContext, SkCanvas* canvas, | 1400 static SkPdfResult PdfOp_B_star(SkPdfContext* pdfContext, SkCanvas* canvas, |
1580 PdfTokenLooper** looper) { | 1401 SkPdfTokenLooper** looper) { |
1581 return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, true); | 1402 return PdfOp_fillAndStroke(pdfContext, canvas, true, true, false, true); |
1582 } | 1403 } |
1583 | 1404 |
1584 static SkPdfResult PdfOp_b(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1405 static SkPdfResult PdfOp_b(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1585 return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, false); | 1406 return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, false); |
1586 } | 1407 } |
1587 | 1408 |
1588 static SkPdfResult PdfOp_b_star(SkPdfContext* pdfContext, SkCanvas* canvas, | 1409 static SkPdfResult PdfOp_b_star(SkPdfContext* pdfContext, SkCanvas* canvas, |
1589 PdfTokenLooper** looper) { | 1410 SkPdfTokenLooper** looper) { |
1590 return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, true); | 1411 return PdfOp_fillAndStroke(pdfContext, canvas, true, true, true, true); |
1591 } | 1412 } |
1592 | 1413 |
1593 static SkPdfResult PdfOp_n(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1414 static SkPdfResult PdfOp_n(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1594 canvas->setMatrix(pdfContext->fGraphicsState.fCTM); | 1415 canvas->setMatrix(pdfContext->fGraphicsState.fCTM); |
1595 if (pdfContext->fGraphicsState.fHasClipPathToApply) { | 1416 if (pdfContext->fGraphicsState.fHasClipPathToApply) { |
1596 #ifndef PDF_DEBUG_NO_CLIPING | 1417 #ifndef PDF_DEBUG_NO_CLIPING |
1597 canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kInters
ect_Op, true); | 1418 canvas->clipPath(pdfContext->fGraphicsState.fClipPath, SkRegion::kInters
ect_Op, true); |
1598 #endif | 1419 #endif |
1599 } | 1420 } |
1600 | 1421 |
1601 pdfContext->fGraphicsState.fHasClipPathToApply = false; | 1422 pdfContext->fGraphicsState.fHasClipPathToApply = false; |
1602 | 1423 |
1603 pdfContext->fGraphicsState.fPathClosed = true; | 1424 pdfContext->fGraphicsState.fPathClosed = true; |
1604 | 1425 |
1605 return kOK_SkPdfResult; | 1426 return kOK_SkPdfResult; |
1606 } | 1427 } |
1607 | 1428 |
1608 static SkPdfResult PdfOp_BT(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1429 static SkPdfResult PdfOp_BT(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1609 pdfContext->fGraphicsState.fTextBlock = true; | 1430 pdfContext->fGraphicsState.fTextBlock = true; |
1610 SkMatrix matrix = pdfContext->fGraphicsState.fCTM; | 1431 SkMatrix matrix = pdfContext->fGraphicsState.fCTM; |
1611 matrix.preScale(SkDoubleToScalar(1), SkDoubleToScalar(-1)); | 1432 matrix.preScale(SkDoubleToScalar(1), SkDoubleToScalar(-1)); |
1612 pdfContext->fGraphicsState.fMatrixTm = matrix; | 1433 pdfContext->fGraphicsState.fMatrixTm = matrix; |
1613 pdfContext->fGraphicsState.fMatrixTlm = matrix; | 1434 pdfContext->fGraphicsState.fMatrixTlm = matrix; |
1614 | 1435 |
1615 return kPartial_SkPdfResult; | 1436 return kPartial_SkPdfResult; |
1616 } | 1437 } |
1617 | 1438 |
1618 static SkPdfResult PdfOp_ET(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1439 static SkPdfResult PdfOp_ET(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1619 if (!pdfContext->fGraphicsState.fTextBlock) { | 1440 if (!pdfContext->fGraphicsState.fTextBlock) { |
1620 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "ET
without BT", NULL, | 1441 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "ET
without BT", NULL, |
1621 pdfContext); | 1442 pdfContext); |
1622 | 1443 |
1623 return kIgnoreError_SkPdfResult; | 1444 return kIgnoreError_SkPdfResult; |
1624 } | 1445 } |
1625 | 1446 |
1626 pdfContext->fGraphicsState.fTextBlock = false; | 1447 pdfContext->fGraphicsState.fTextBlock = false; |
1627 | 1448 |
1628 // TODO(edisonn): anything else to be done once we are done with draw text?
Like restore stack? | 1449 // TODO(edisonn): anything else to be done once we are done with draw text?
Like restore stack? |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1661 } | 1482 } |
1662 pdfContext->fGraphicsState.fCurFontSize = fontSize; | 1483 pdfContext->fGraphicsState.fCurFontSize = fontSize; |
1663 return kOK_SkPdfResult; | 1484 return kOK_SkPdfResult; |
1664 } | 1485 } |
1665 | 1486 |
1666 //font size Tf Set the text font, Tf | 1487 //font size Tf Set the text font, Tf |
1667 //, to font and the text font size, Tfs, to size. font is the name of a | 1488 //, to font and the text font size, Tfs, to size. font is the name of a |
1668 //font resource in the Fontsubdictionary of the current resource dictionary; siz
e is | 1489 //font resource in the Fontsubdictionary of the current resource dictionary; siz
e is |
1669 //a number representing a scale factor. There is no initial value for either fon
t or | 1490 //a number representing a scale factor. There is no initial value for either fon
t or |
1670 //size; they must be specified explicitly using Tf before any text is shown. | 1491 //size; they must be specified explicitly using Tf before any text is shown. |
1671 static SkPdfResult PdfOp_Tf(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1492 static SkPdfResult PdfOp_Tf(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1672 EXPECT_OPERANDS("Tf", pdfContext, 2); | 1493 EXPECT_OPERANDS("Tf", pdfContext, 2); |
1673 POP_NUMBER(pdfContext, fontSize); | 1494 POP_NUMBER(pdfContext, fontSize); |
1674 POP_NAME(pdfContext, fontName); | 1495 POP_NAME(pdfContext, fontName); |
1675 CHECK_PARAMETERS(); | 1496 CHECK_PARAMETERS(); |
1676 | 1497 |
1677 return skpdfGraphicsStateApplyFontCore(pdfContext, fontName, fontSize); | 1498 return skpdfGraphicsStateApplyFontCore(pdfContext, fontName, fontSize); |
1678 } | 1499 } |
1679 | 1500 |
1680 static SkPdfResult PdfOp_Tj(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1501 static SkPdfResult PdfOp_Tj(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1681 EXPECT_OPERANDS("Tj", pdfContext, 1); | 1502 EXPECT_OPERANDS("Tj", pdfContext, 1); |
1682 POP_STRING(pdfContext, str); | 1503 POP_STRING(pdfContext, str); |
1683 CHECK_PARAMETERS(); | 1504 CHECK_PARAMETERS(); |
1684 | 1505 |
1685 if (!pdfContext->fGraphicsState.fTextBlock) { | 1506 if (!pdfContext->fGraphicsState.fTextBlock) { |
1686 // TODO(edisonn): try to recover and draw it any way? | 1507 // TODO(edisonn): try to recover and draw it any way? |
1687 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "Tj
without BT", NULL, | 1508 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "Tj
without BT", NULL, |
1688 pdfContext); | 1509 pdfContext); |
1689 return kIgnoreError_SkPdfResult; | 1510 return kIgnoreError_SkPdfResult; |
1690 } | 1511 } |
1691 | 1512 |
1692 SkPdfResult ret = DrawText(pdfContext, str, canvas); | 1513 SkPdfResult ret = DrawText(pdfContext, str, canvas); |
1693 | 1514 |
1694 return ret; | 1515 return ret; |
1695 } | 1516 } |
1696 | 1517 |
1697 static SkPdfResult PdfOp_quote(SkPdfContext* pdfContext, SkCanvas* canvas, | 1518 static SkPdfResult PdfOp_quote(SkPdfContext* pdfContext, SkCanvas* canvas, |
1698 PdfTokenLooper** looper) { | 1519 SkPdfTokenLooper** looper) { |
1699 if (!pdfContext->fGraphicsState.fTextBlock) { | 1520 if (!pdfContext->fGraphicsState.fTextBlock) { |
1700 // TODO(edisonn): try to recover and draw it any way? | 1521 // TODO(edisonn): try to recover and draw it any way? |
1701 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, | 1522 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, |
1702 "' without BT", NULL, pdfContext); | 1523 "' without BT", NULL, pdfContext); |
1703 return kIgnoreError_SkPdfResult; | 1524 return kIgnoreError_SkPdfResult; |
1704 } | 1525 } |
1705 | 1526 |
1706 PdfOp_T_star(pdfContext, canvas, looper); | 1527 PdfOp_T_star(pdfContext, canvas, looper); |
1707 // Do not pop, and push, just transfer the param to Tj | 1528 // Do not pop, and push, just transfer the param to Tj |
1708 return PdfOp_Tj(pdfContext, canvas, looper); | 1529 return PdfOp_Tj(pdfContext, canvas, looper); |
1709 } | 1530 } |
1710 | 1531 |
1711 static SkPdfResult PdfOp_doublequote(SkPdfContext* pdfContext, SkCanvas* canvas, | 1532 static SkPdfResult PdfOp_doublequote(SkPdfContext* pdfContext, SkCanvas* canvas, |
1712 PdfTokenLooper** looper) { | 1533 SkPdfTokenLooper** looper) { |
1713 if (!pdfContext->fGraphicsState.fTextBlock) { | 1534 if (!pdfContext->fGraphicsState.fTextBlock) { |
1714 // TODO(edisonn): try to recover and draw it any way? | 1535 // TODO(edisonn): try to recover and draw it any way? |
1715 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, | 1536 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, |
1716 "\" without BT", NULL, pdfContext); | 1537 "\" without BT", NULL, pdfContext); |
1717 return kIgnoreError_SkPdfResult; | 1538 return kIgnoreError_SkPdfResult; |
1718 } | 1539 } |
1719 | 1540 |
1720 EXPECT_OPERANDS("\"", pdfContext, 3); | 1541 EXPECT_OPERANDS("\"", pdfContext, 3); |
1721 POP_OBJ(pdfContext, str); | 1542 POP_OBJ(pdfContext, str); |
1722 POP_OBJ(pdfContext, ac); | 1543 POP_OBJ(pdfContext, ac); |
1723 POP_OBJ(pdfContext, aw); | 1544 POP_OBJ(pdfContext, aw); |
1724 CHECK_PARAMETERS(); | 1545 CHECK_PARAMETERS(); |
1725 | 1546 |
1726 pdfContext->fObjectStack.push(aw); | 1547 pdfContext->fObjectStack.push(aw); |
1727 PdfOp_Tw(pdfContext, canvas, looper); | 1548 PdfOp_Tw(pdfContext, canvas, looper); |
1728 | 1549 |
1729 pdfContext->fObjectStack.push(ac); | 1550 pdfContext->fObjectStack.push(ac); |
1730 PdfOp_Tc(pdfContext, canvas, looper); | 1551 PdfOp_Tc(pdfContext, canvas, looper); |
1731 | 1552 |
1732 pdfContext->fObjectStack.push(str); | 1553 pdfContext->fObjectStack.push(str); |
1733 PdfOp_quote(pdfContext, canvas, looper); | 1554 PdfOp_quote(pdfContext, canvas, looper); |
1734 | 1555 |
1735 return kPartial_SkPdfResult; | 1556 return kPartial_SkPdfResult; |
1736 } | 1557 } |
1737 | 1558 |
1738 static SkPdfResult PdfOp_TJ(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1559 static SkPdfResult PdfOp_TJ(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1739 EXPECT_OPERANDS("Tf", pdfContext, 1); | 1560 EXPECT_OPERANDS("Tf", pdfContext, 1); |
1740 POP_ARRAY(pdfContext, array); | 1561 POP_ARRAY(pdfContext, array); |
1741 CHECK_PARAMETERS(); | 1562 CHECK_PARAMETERS(); |
1742 | 1563 |
1743 if (!pdfContext->fGraphicsState.fTextBlock) { | 1564 if (!pdfContext->fGraphicsState.fTextBlock) { |
1744 // TODO(edisonn): try to recover and draw it any way? | 1565 // TODO(edisonn): try to recover and draw it any way? |
1745 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "TJ
without BT", NULL, | 1566 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingBT_SkPdfIssue, "TJ
without BT", NULL, |
1746 pdfContext); | 1567 pdfContext); |
1747 return kIgnoreError_SkPdfResult; | 1568 return kIgnoreError_SkPdfResult; |
1748 } | 1569 } |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1842 return kPartial_SkPdfResult; | 1663 return kPartial_SkPdfResult; |
1843 } | 1664 } |
1844 return kNYI_SkPdfResult; | 1665 return kNYI_SkPdfResult; |
1845 } | 1666 } |
1846 } | 1667 } |
1847 } | 1668 } |
1848 | 1669 |
1849 return kPartial_SkPdfResult; | 1670 return kPartial_SkPdfResult; |
1850 } | 1671 } |
1851 | 1672 |
1852 static SkPdfResult PdfOp_CS(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1673 static SkPdfResult PdfOp_CS(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1853 return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking
); | 1674 return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking
); |
1854 } | 1675 } |
1855 | 1676 |
1856 static SkPdfResult PdfOp_cs(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1677 static SkPdfResult PdfOp_cs(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1857 return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStrok
ing); | 1678 return PdfOp_CS_cs(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStrok
ing); |
1858 } | 1679 } |
1859 | 1680 |
1860 static SkPdfResult PdfOp_SC_sc(SkPdfContext* pdfContext, SkCanvas* canvas, | 1681 static SkPdfResult PdfOp_SC_sc(SkPdfContext* pdfContext, SkCanvas* canvas, |
1861 SkPdfColorOperator* colorOperator) { | 1682 SkPdfColorOperator* colorOperator) { |
1862 double c[4]; | 1683 double c[4]; |
1863 // int64_t v[4]; | 1684 // int64_t v[4]; |
1864 | 1685 |
1865 int n = GetColorSpaceComponents(colorOperator->fColorSpace); | 1686 int n = GetColorSpaceComponents(colorOperator->fColorSpace); |
1866 | 1687 |
(...skipping 22 matching lines...) Expand all Loading... |
1889 // TODO(edisonn): support also abbreviations /DeviceRGB == /RGB | 1710 // TODO(edisonn): support also abbreviations /DeviceRGB == /RGB |
1890 if (colorOperator->fColorSpace.equals("DeviceRGB") || | 1711 if (colorOperator->fColorSpace.equals("DeviceRGB") || |
1891 colorOperator->fColorSpace.equals("RGB")) { | 1712 colorOperator->fColorSpace.equals("RGB")) { |
1892 colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255*c[0]), | 1713 colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255*c[0]), |
1893 (U8CPU)(255*c[1]), | 1714 (U8CPU)(255*c[1]), |
1894 (U8CPU)(255*c[2]))); | 1715 (U8CPU)(255*c[2]))); |
1895 } | 1716 } |
1896 return kPartial_SkPdfResult; | 1717 return kPartial_SkPdfResult; |
1897 } | 1718 } |
1898 | 1719 |
1899 static SkPdfResult PdfOp_SC(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1720 static SkPdfResult PdfOp_SC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1900 return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking
); | 1721 return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking
); |
1901 } | 1722 } |
1902 | 1723 |
1903 static SkPdfResult PdfOp_sc(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1724 static SkPdfResult PdfOp_sc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1904 return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStrok
ing); | 1725 return PdfOp_SC_sc(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStrok
ing); |
1905 } | 1726 } |
1906 | 1727 |
1907 static SkPdfResult PdfOp_SCN_scn(SkPdfContext* pdfContext, SkCanvas* canvas, | 1728 static SkPdfResult PdfOp_SCN_scn(SkPdfContext* pdfContext, SkCanvas* canvas, |
1908 SkPdfColorOperator* colorOperator) { | 1729 SkPdfColorOperator* colorOperator) { |
1909 if (pdfContext->fObjectStack.count() > 0 && pdfContext->fObjectStack.top()->
isName()) { | 1730 if (pdfContext->fObjectStack.count() > 0 && pdfContext->fObjectStack.top()->
isName()) { |
1910 SkPdfNativeObject* name = pdfContext->fObjectStack.top(); pdfContext-
>fObjectStack.pop(); | 1731 SkPdfNativeObject* name = pdfContext->fObjectStack.top(); pdfContext-
>fObjectStack.pop(); |
1911 | 1732 |
1912 SkPdfDictionary* patternResources | 1733 SkPdfDictionary* patternResources |
1913 = pdfContext->fGraphicsState.fResources->Pattern(pdfContext->fPd
fDoc); | 1734 = pdfContext->fGraphicsState.fResources->Pattern(pdfContext->fPd
fDoc); |
1914 | 1735 |
1915 if (patternResources == NULL) { | 1736 if (patternResources == NULL) { |
1916 #ifdef PDF_TRACE | 1737 #ifdef PDF_TRACE |
1917 printf("ExtGState is NULL!\n"); | 1738 printf("ExtGState is NULL!\n"); |
1918 #endif | 1739 #endif |
1919 return kIgnoreError_SkPdfResult; | 1740 return kIgnoreError_SkPdfResult; |
1920 } | 1741 } |
1921 | 1742 |
1922 colorOperator->setPatternColorSpace( | 1743 colorOperator->setPatternColorSpace( |
1923 pdfContext->fPdfDoc->resolveReference(patternResources->get(name
))); | 1744 pdfContext->fPdfDoc->resolveReference(patternResources->get(name
))); |
1924 } | 1745 } |
1925 | 1746 |
1926 // TODO(edisonn): SCN supports more color spaces than SCN. Read and implemen
t spec. | 1747 // TODO(edisonn): SCN supports more color spaces than SCN. Read and implemen
t spec. |
1927 PdfOp_SC_sc(pdfContext, canvas, colorOperator); | 1748 PdfOp_SC_sc(pdfContext, canvas, colorOperator); |
1928 | 1749 |
1929 return kPartial_SkPdfResult; | 1750 return kPartial_SkPdfResult; |
1930 } | 1751 } |
1931 | 1752 |
1932 static SkPdfResult PdfOp_SCN(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToke
nLooper** looper) { | 1753 static SkPdfResult PdfOp_SCN(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTo
kenLooper** looper) { |
1933 return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fStroki
ng); | 1754 return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fStroki
ng); |
1934 } | 1755 } |
1935 | 1756 |
1936 static SkPdfResult PdfOp_scn(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToke
nLooper** looper) { | 1757 static SkPdfResult PdfOp_scn(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTo
kenLooper** looper) { |
1937 return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStr
oking); | 1758 return PdfOp_SCN_scn(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStr
oking); |
1938 } | 1759 } |
1939 | 1760 |
1940 static SkPdfResult PdfOp_G_g(SkPdfContext* pdfContext, SkCanvas* canvas, | 1761 static SkPdfResult PdfOp_G_g(SkPdfContext* pdfContext, SkCanvas* canvas, |
1941 SkPdfColorOperator* colorOperator) { | 1762 SkPdfColorOperator* colorOperator) { |
1942 EXPECT_OPERANDS("G/g", pdfContext, 1); | 1763 EXPECT_OPERANDS("G/g", pdfContext, 1); |
1943 POP_NUMBER(pdfContext, gray); | 1764 POP_NUMBER(pdfContext, gray); |
1944 CHECK_PARAMETERS(); | 1765 CHECK_PARAMETERS(); |
1945 | 1766 |
1946 // TODO(edisonn): limit gray in [0, 1] | 1767 // TODO(edisonn): limit gray in [0, 1] |
1947 | 1768 |
1948 // TODO(edisonn): HACK - it should be device gray, but not suported right no
w | 1769 // TODO(edisonn): HACK - it should be device gray, but not suported right no
w |
1949 colorOperator->fColorSpace = strings_DeviceRGB; | 1770 colorOperator->fColorSpace = strings_DeviceRGB; |
1950 colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255 * gray), | 1771 colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255 * gray), |
1951 (U8CPU)(255 * gray), | 1772 (U8CPU)(255 * gray), |
1952 (U8CPU)(255 * gray))); | 1773 (U8CPU)(255 * gray))); |
1953 | 1774 |
1954 return kPartial_SkPdfResult; | 1775 return kPartial_SkPdfResult; |
1955 } | 1776 } |
1956 | 1777 |
1957 static SkPdfResult PdfOp_G(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1778 static SkPdfResult PdfOp_G(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1958 return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking); | 1779 return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking); |
1959 } | 1780 } |
1960 | 1781 |
1961 static SkPdfResult PdfOp_g(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1782 static SkPdfResult PdfOp_g(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
1962 return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStrokin
g); | 1783 return PdfOp_G_g(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStrokin
g); |
1963 } | 1784 } |
1964 | 1785 |
1965 static SkPdfResult PdfOp_RG_rg(SkPdfContext* pdfContext, SkCanvas* canvas, | 1786 static SkPdfResult PdfOp_RG_rg(SkPdfContext* pdfContext, SkCanvas* canvas, |
1966 SkPdfColorOperator* colorOperator) { | 1787 SkPdfColorOperator* colorOperator) { |
1967 EXPECT_OPERANDS("RG/rg", pdfContext, 3); | 1788 EXPECT_OPERANDS("RG/rg", pdfContext, 3); |
1968 POP_NUMBER(pdfContext, b); | 1789 POP_NUMBER(pdfContext, b); |
1969 POP_NUMBER(pdfContext, g); | 1790 POP_NUMBER(pdfContext, g); |
1970 POP_NUMBER(pdfContext, r); | 1791 POP_NUMBER(pdfContext, r); |
1971 CHECK_PARAMETERS(); | 1792 CHECK_PARAMETERS(); |
1972 | 1793 |
1973 colorOperator->fColorSpace = strings_DeviceRGB; | 1794 colorOperator->fColorSpace = strings_DeviceRGB; |
1974 colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255*r), (U8CPU)(255*g), (U8
CPU)(255*b))); | 1795 colorOperator->setRGBColor(SkColorSetRGB((U8CPU)(255*r), (U8CPU)(255*g), (U8
CPU)(255*b))); |
1975 return kOK_SkPdfResult; | 1796 return kOK_SkPdfResult; |
1976 } | 1797 } |
1977 | 1798 |
1978 static SkPdfResult PdfOp_RG(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1799 static SkPdfResult PdfOp_RG(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1979 return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking
); | 1800 return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking
); |
1980 } | 1801 } |
1981 | 1802 |
1982 static SkPdfResult PdfOp_rg(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1803 static SkPdfResult PdfOp_rg(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
1983 return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStrok
ing); | 1804 return PdfOp_RG_rg(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStrok
ing); |
1984 } | 1805 } |
1985 | 1806 |
1986 static SkPdfResult PdfOp_K_k(SkPdfContext* pdfContext, SkCanvas* canvas, | 1807 static SkPdfResult PdfOp_K_k(SkPdfContext* pdfContext, SkCanvas* canvas, |
1987 SkPdfColorOperator* colorOperator) { | 1808 SkPdfColorOperator* colorOperator) { |
1988 // TODO(edisonn): spec has some rules about overprint, implement them. | 1809 // TODO(edisonn): spec has some rules about overprint, implement them. |
1989 EXPECT_OPERANDS("K/k", pdfContext, 4); | 1810 EXPECT_OPERANDS("K/k", pdfContext, 4); |
1990 POP_NUMBER(pdfContext, k); | 1811 POP_NUMBER(pdfContext, k); |
1991 POP_NUMBER(pdfContext, y); | 1812 POP_NUMBER(pdfContext, y); |
1992 POP_NUMBER(pdfContext, m); | 1813 POP_NUMBER(pdfContext, m); |
1993 POP_NUMBER(pdfContext, c); | 1814 POP_NUMBER(pdfContext, c); |
1994 CHECK_PARAMETERS(); | 1815 CHECK_PARAMETERS(); |
1995 | 1816 |
1996 // TODO(edisonn): really silly quick way to remove compiler warning | 1817 // TODO(edisonn): really silly quick way to remove compiler warning |
1997 if (k + y + m + c == 0) { | 1818 if (k + y + m + c == 0) { |
1998 return kNYI_SkPdfResult; | 1819 return kNYI_SkPdfResult; |
1999 } | 1820 } |
2000 | 1821 |
2001 //colorOperator->fColorSpace = strings_DeviceCMYK; | 1822 //colorOperator->fColorSpace = strings_DeviceCMYK; |
2002 // TODO(edisonn): Set color. | 1823 // TODO(edisonn): Set color. |
2003 return kNYI_SkPdfResult; | 1824 return kNYI_SkPdfResult; |
2004 } | 1825 } |
2005 | 1826 |
2006 static SkPdfResult PdfOp_K(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1827 static SkPdfResult PdfOp_K(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
2007 return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking); | 1828 return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fStroking); |
2008 } | 1829 } |
2009 | 1830 |
2010 static SkPdfResult PdfOp_k(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1831 static SkPdfResult PdfOp_k(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
2011 return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStrokin
g); | 1832 return PdfOp_K_k(pdfContext, canvas, &pdfContext->fGraphicsState.fNonStrokin
g); |
2012 } | 1833 } |
2013 | 1834 |
2014 static SkPdfResult PdfOp_W(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 1835 static SkPdfResult PdfOp_W(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
2015 pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath; | 1836 pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath; |
2016 pdfContext->fGraphicsState.fHasClipPathToApply = true; | 1837 pdfContext->fGraphicsState.fHasClipPathToApply = true; |
2017 | 1838 |
2018 return kOK_SkPdfResult; | 1839 return kOK_SkPdfResult; |
2019 } | 1840 } |
2020 | 1841 |
2021 static SkPdfResult PdfOp_W_star(SkPdfContext* pdfContext, SkCanvas* canvas, | 1842 static SkPdfResult PdfOp_W_star(SkPdfContext* pdfContext, SkCanvas* canvas, |
2022 PdfTokenLooper** looper) { | 1843 SkPdfTokenLooper** looper) { |
2023 pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath; | 1844 pdfContext->fGraphicsState.fClipPath = pdfContext->fGraphicsState.fPath; |
2024 | 1845 |
2025 pdfContext->fGraphicsState.fClipPath.setFillType(SkPath::kEvenOdd_FillType); | 1846 pdfContext->fGraphicsState.fClipPath.setFillType(SkPath::kEvenOdd_FillType); |
2026 pdfContext->fGraphicsState.fHasClipPathToApply = true; | 1847 pdfContext->fGraphicsState.fHasClipPathToApply = true; |
2027 | 1848 |
2028 return kOK_SkPdfResult; | 1849 return kOK_SkPdfResult; |
2029 } | 1850 } |
2030 | 1851 |
2031 static SkPdfResult PdfOp_BX(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1852 static SkPdfResult PdfOp_BX(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2032 *looper = new PdfCompatibilitySectionLooper(); | 1853 *looper = new PdfCompatibilitySectionLooper(); |
2033 return kOK_SkPdfResult; | 1854 return kOK_SkPdfResult; |
2034 } | 1855 } |
2035 | 1856 |
2036 static SkPdfResult PdfOp_EX(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1857 static SkPdfResult PdfOp_EX(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2037 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue, | 1858 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue, |
2038 "EX operator should not be called, it is handled in a looper, " | 1859 "EX operator should not be called, it is handled in a looper, " |
2039 "unless the file is corrupted, we should assert", | 1860 "unless the file is corrupted, we should assert", |
2040 NULL, pdfContext); | 1861 NULL, pdfContext); |
2041 | 1862 |
2042 return kIgnoreError_SkPdfResult; | 1863 return kIgnoreError_SkPdfResult; |
2043 } | 1864 } |
2044 | 1865 |
2045 static SkPdfResult PdfOp_BI(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1866 static SkPdfResult PdfOp_BI(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2046 *looper = new PdfInlineImageLooper(); | 1867 *looper = new PdfInlineImageLooper(); |
2047 return kOK_SkPdfResult; | 1868 return kOK_SkPdfResult; |
2048 } | 1869 } |
2049 | 1870 |
2050 static SkPdfResult PdfOp_ID(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1871 static SkPdfResult PdfOp_ID(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2051 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue, | 1872 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue, |
2052 "ID operator should not be called, it is habdled in a looper, " | 1873 "ID operator should not be called, it is habdled in a looper, " |
2053 "unless the file is corrupted, we should assert", | 1874 "unless the file is corrupted, we should assert", |
2054 NULL, pdfContext); | 1875 NULL, pdfContext); |
2055 return kIgnoreError_SkPdfResult; | 1876 return kIgnoreError_SkPdfResult; |
2056 } | 1877 } |
2057 | 1878 |
2058 static SkPdfResult PdfOp_EI(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 1879 static SkPdfResult PdfOp_EI(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2059 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue, | 1880 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kNullObject_SkPdfIssue, |
2060 "EI operator should not be called, it is habdled in a looper, " | 1881 "EI operator should not be called, it is habdled in a looper, " |
2061 "unless the file is corrupted, we should assert", | 1882 "unless the file is corrupted, we should assert", |
2062 NULL, pdfContext); | 1883 NULL, pdfContext); |
2063 return kIgnoreError_SkPdfResult; | 1884 return kIgnoreError_SkPdfResult; |
2064 } | 1885 } |
2065 | 1886 |
2066 static SkPdfResult skpdfGraphicsStateApply_ca(SkPdfContext* pdfContext, double c
a) { | 1887 static SkPdfResult skpdfGraphicsStateApply_ca(SkPdfContext* pdfContext, double c
a) { |
2067 pdfContext->fGraphicsState.fNonStroking.fOpacity = ca; | 1888 pdfContext->fGraphicsState.fNonStroking.fOpacity = ca; |
2068 return kOK_SkPdfResult; | 1889 return kOK_SkPdfResult; |
(...skipping 144 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2213 SkPdfNativeObject::_kNumber_PdfObjectType, pdf
Context); | 2034 SkPdfNativeObject::_kNumber_PdfObjectType, pdf
Context); |
2214 return; | 2035 return; |
2215 } | 2036 } |
2216 | 2037 |
2217 skpdfGraphicsStateApplyFontCore(pdfContext, fontAndSize->objAtAIndex(0), | 2038 skpdfGraphicsStateApplyFontCore(pdfContext, fontAndSize->objAtAIndex(0), |
2218 fontAndSize->objAtAIndex(1)->numberValue()); | 2039 fontAndSize->objAtAIndex(1)->numberValue()); |
2219 } | 2040 } |
2220 | 2041 |
2221 | 2042 |
2222 //lineWidth w Set the line width in the graphics state (see “Line Width” on page
152). | 2043 //lineWidth w Set the line width in the graphics state (see “Line Width” on page
152). |
2223 static SkPdfResult PdfOp_w(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 2044 static SkPdfResult PdfOp_w(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
2224 EXPECT_OPERANDS("w", pdfContext, 1); | 2045 EXPECT_OPERANDS("w", pdfContext, 1); |
2225 POP_NUMBER(pdfContext, lw); | 2046 POP_NUMBER(pdfContext, lw); |
2226 CHECK_PARAMETERS(); | 2047 CHECK_PARAMETERS(); |
2227 | 2048 |
2228 return skpdfGraphicsStateApplyLW(pdfContext, lw); | 2049 return skpdfGraphicsStateApplyLW(pdfContext, lw); |
2229 } | 2050 } |
2230 | 2051 |
2231 //lineCap J Set the line cap style in the graphics state (see “Line Cap Style” o
n page 153). | 2052 //lineCap J Set the line cap style in the graphics state (see “Line Cap Style” o
n page 153). |
2232 static SkPdfResult PdfOp_J(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 2053 static SkPdfResult PdfOp_J(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
2233 // TODO(edisonn): round/ceil to int? | 2054 // TODO(edisonn): round/ceil to int? |
2234 EXPECT_OPERANDS("J", pdfContext, 1); | 2055 EXPECT_OPERANDS("J", pdfContext, 1); |
2235 POP_NUMBER(pdfContext, lc); | 2056 POP_NUMBER(pdfContext, lc); |
2236 CHECK_PARAMETERS(); | 2057 CHECK_PARAMETERS(); |
2237 | 2058 |
2238 return skpdfGraphicsStateApplyLC(pdfContext, (int)lc); | 2059 return skpdfGraphicsStateApplyLC(pdfContext, (int)lc); |
2239 } | 2060 } |
2240 | 2061 |
2241 //lineJoin j Set the line join style in the graphics state (see “Line Join Style
” on page 153). | 2062 //lineJoin j Set the line join style in the graphics state (see “Line Join Style
” on page 153). |
2242 static SkPdfResult PdfOp_j(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 2063 static SkPdfResult PdfOp_j(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
2243 // TODO(edisonn): round/ceil to int? | 2064 // TODO(edisonn): round/ceil to int? |
2244 EXPECT_OPERANDS("j", pdfContext, 1); | 2065 EXPECT_OPERANDS("j", pdfContext, 1); |
2245 POP_NUMBER(pdfContext, lj); | 2066 POP_NUMBER(pdfContext, lj); |
2246 CHECK_PARAMETERS(); | 2067 CHECK_PARAMETERS(); |
2247 | 2068 |
2248 return skpdfGraphicsStateApplyLJ(pdfContext, (int)lj); | 2069 return skpdfGraphicsStateApplyLJ(pdfContext, (int)lj); |
2249 } | 2070 } |
2250 | 2071 |
2251 //miterLimit M Set the miter limit in the graphics state (see “Miter Limit” on p
age 153). | 2072 //miterLimit M Set the miter limit in the graphics state (see “Miter Limit” on p
age 153). |
2252 static SkPdfResult PdfOp_M(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 2073 static SkPdfResult PdfOp_M(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
2253 EXPECT_OPERANDS("M", pdfContext, 1); | 2074 EXPECT_OPERANDS("M", pdfContext, 1); |
2254 POP_NUMBER(pdfContext, ml); | 2075 POP_NUMBER(pdfContext, ml); |
2255 CHECK_PARAMETERS(); | 2076 CHECK_PARAMETERS(); |
2256 return skpdfGraphicsStateApplyML(pdfContext, ml); | 2077 return skpdfGraphicsStateApplyML(pdfContext, ml); |
2257 } | 2078 } |
2258 | 2079 |
2259 //dashArray dashPhase d Set the line dash pattern in the graphics state (see “Li
ne Dash Pattern” on | 2080 //dashArray dashPhase d Set the line dash pattern in the graphics state (see “Li
ne Dash Pattern” on |
2260 //page 155). | 2081 //page 155). |
2261 static SkPdfResult PdfOp_d(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 2082 static SkPdfResult PdfOp_d(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
2262 EXPECT_OPERANDS("d", pdfContext, 2); | 2083 EXPECT_OPERANDS("d", pdfContext, 2); |
2263 POP_OBJ(pdfContext, phase); | 2084 POP_OBJ(pdfContext, phase); |
2264 POP_ARRAY(pdfContext, array); | 2085 POP_ARRAY(pdfContext, array); |
2265 CHECK_PARAMETERS(); | 2086 CHECK_PARAMETERS(); |
2266 | 2087 |
2267 return skpdfGraphicsStateApplyD(pdfContext, array, phase); | 2088 return skpdfGraphicsStateApplyD(pdfContext, array, phase); |
2268 } | 2089 } |
2269 | 2090 |
2270 //intent ri (PDF 1.1) Set the color rendering intent in the graphics state (see
“Rendering Intents” | 2091 //intent ri (PDF 1.1) Set the color rendering intent in the graphics state (see
“Rendering Intents” |
2271 // on page 197). | 2092 // on page 197). |
2272 static SkPdfResult PdfOp_ri(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 2093 static SkPdfResult PdfOp_ri(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2273 pdfContext->fObjectStack.pop(); | 2094 pdfContext->fObjectStack.pop(); |
2274 | 2095 |
2275 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "render intent
NYI", NULL, | 2096 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "render intent
NYI", NULL, |
2276 pdfContext); | 2097 pdfContext); |
2277 | 2098 |
2278 return kNYI_SkPdfResult; | 2099 return kNYI_SkPdfResult; |
2279 } | 2100 } |
2280 | 2101 |
2281 //flatness i Set the flatness tolerance in the graphics state (see Section 6.5.1,
“Flatness | 2102 //flatness i Set the flatness tolerance in the graphics state (see Section 6.5.1,
“Flatness |
2282 //Tolerance”). flatness is a number in the range 0 to 100; a value of 0 speci- | 2103 //Tolerance”). flatness is a number in the range 0 to 100; a value of 0 speci- |
2283 //fies the output device’s default flatness tolerance. | 2104 //fies the output device’s default flatness tolerance. |
2284 static SkPdfResult PdfOp_i(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenL
ooper** looper) { | 2105 static SkPdfResult PdfOp_i(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfToke
nLooper** looper) { |
2285 EXPECT_OPERANDS("i", pdfContext, 1); | 2106 EXPECT_OPERANDS("i", pdfContext, 1); |
2286 POP_NUMBER(pdfContext, flatness); | 2107 POP_NUMBER(pdfContext, flatness); |
2287 CHECK_PARAMETERS(); | 2108 CHECK_PARAMETERS(); |
2288 | 2109 |
2289 if (flatness < 0 || flatness > 100) { | 2110 if (flatness < 0 || flatness > 100) { |
2290 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, | 2111 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, |
2291 "flatness must be a real in [0, 100] range", flatness_obj, p
dfContext); | 2112 "flatness must be a real in [0, 100] range", flatness_obj, p
dfContext); |
2292 return kIgnoreError_SkPdfResult; | 2113 return kIgnoreError_SkPdfResult; |
2293 } | 2114 } |
2294 | 2115 |
(...skipping 136 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2431 } | 2252 } |
2432 | 2253 |
2433 static void skpdfGraphicsStateApplyAIS(SkPdfContext* pdfContext, bool alphaSourc
e) { | 2254 static void skpdfGraphicsStateApplyAIS(SkPdfContext* pdfContext, bool alphaSourc
e) { |
2434 pdfContext->fGraphicsState.fAlphaSource = alphaSource; | 2255 pdfContext->fGraphicsState.fAlphaSource = alphaSource; |
2435 } | 2256 } |
2436 | 2257 |
2437 | 2258 |
2438 //dictName gs (PDF 1.2) Set the specified parameters in the graphics state. dictN
ame is | 2259 //dictName gs (PDF 1.2) Set the specified parameters in the graphics state. dictN
ame is |
2439 //the name of a graphics state parameter dictionary in the ExtGState subdictiona
ry of the current | 2260 //the name of a graphics state parameter dictionary in the ExtGState subdictiona
ry of the current |
2440 //resource dictionary (see the next section). | 2261 //resource dictionary (see the next section). |
2441 static SkPdfResult PdfOp_gs(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 2262 static SkPdfResult PdfOp_gs(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2442 EXPECT_OPERANDS("gs", pdfContext, 1); | 2263 EXPECT_OPERANDS("gs", pdfContext, 1); |
2443 POP_NAME(pdfContext, name); | 2264 POP_NAME(pdfContext, name); |
2444 CHECK_PARAMETERS(); | 2265 CHECK_PARAMETERS(); |
2445 | 2266 |
2446 SkPdfDictionary* extGStateDictionary | 2267 SkPdfDictionary* extGStateDictionary |
2447 = pdfContext->fGraphicsState.fResources->ExtGState(pdfContext->fPdfD
oc); | 2268 = pdfContext->fGraphicsState.fResources->ExtGState(pdfContext->fPdfD
oc); |
2448 | 2269 |
2449 if (extGStateDictionary == NULL) { | 2270 if (extGStateDictionary == NULL) { |
2450 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingExtGState_SkPdfIssu
e, NULL, | 2271 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingExtGState_SkPdfIssu
e, NULL, |
2451 pdfContext->fGraphicsState.fResources, pdfContext); | 2272 pdfContext->fGraphicsState.fResources, pdfContext); |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2533 | 2354 |
2534 // TODO(edisonn): make sure we loaded all those properties in graphic state. | 2355 // TODO(edisonn): make sure we loaded all those properties in graphic state. |
2535 | 2356 |
2536 return kOK_SkPdfResult; | 2357 return kOK_SkPdfResult; |
2537 } | 2358 } |
2538 | 2359 |
2539 //charSpace Tc Set the character spacing, Tc | 2360 //charSpace Tc Set the character spacing, Tc |
2540 //, to charSpace, which is a number expressed in unscaled text space units. | 2361 //, to charSpace, which is a number expressed in unscaled text space units. |
2541 // Character spacing is used by the Tj, TJ, and ' operators. | 2362 // Character spacing is used by the Tj, TJ, and ' operators. |
2542 //Initial value: 0. | 2363 //Initial value: 0. |
2543 SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper*
* looper) { | 2364 SkPdfResult PdfOp_Tc(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLoope
r** looper) { |
2544 EXPECT_OPERANDS("Tc", pdfContext, 1); | 2365 EXPECT_OPERANDS("Tc", pdfContext, 1); |
2545 POP_NUMBER(pdfContext, charSpace); | 2366 POP_NUMBER(pdfContext, charSpace); |
2546 CHECK_PARAMETERS(); | 2367 CHECK_PARAMETERS(); |
2547 | 2368 |
2548 pdfContext->fGraphicsState.fCharSpace = charSpace; | 2369 pdfContext->fGraphicsState.fCharSpace = charSpace; |
2549 | 2370 |
2550 return kOK_SkPdfResult; | 2371 return kOK_SkPdfResult; |
2551 } | 2372 } |
2552 | 2373 |
2553 //wordSpace Tw Set the word spacing, T | 2374 //wordSpace Tw Set the word spacing, T |
2554 //w | 2375 //w |
2555 //, to wordSpace, which is a number expressed in unscaled | 2376 //, to wordSpace, which is a number expressed in unscaled |
2556 //text space units. Word spacing is used by the Tj, TJ, and ' operators. Initial | 2377 //text space units. Word spacing is used by the Tj, TJ, and ' operators. Initial |
2557 //value: 0. | 2378 //value: 0. |
2558 SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper*
* looper) { | 2379 SkPdfResult PdfOp_Tw(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTokenLoope
r** looper) { |
2559 EXPECT_OPERANDS("Tw", pdfContext, 1); | 2380 EXPECT_OPERANDS("Tw", pdfContext, 1); |
2560 POP_NUMBER(pdfContext, wordSpace); | 2381 POP_NUMBER(pdfContext, wordSpace); |
2561 CHECK_PARAMETERS(); | 2382 CHECK_PARAMETERS(); |
2562 | 2383 |
2563 pdfContext->fGraphicsState.fWordSpace = wordSpace; | 2384 pdfContext->fGraphicsState.fWordSpace = wordSpace; |
2564 | 2385 |
2565 return kOK_SkPdfResult; | 2386 return kOK_SkPdfResult; |
2566 } | 2387 } |
2567 | 2388 |
2568 //scale Tz Set the horizontal scaling, Th | 2389 //scale Tz Set the horizontal scaling, Th |
2569 //, to (scale ˜ 100). scale is a number specifying the | 2390 //, to (scale ˜ 100). scale is a number specifying the |
2570 //percentage of the normal width. Initial value: 100 (normal width). | 2391 //percentage of the normal width. Initial value: 100 (normal width). |
2571 static SkPdfResult PdfOp_Tz(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 2392 static SkPdfResult PdfOp_Tz(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2572 EXPECT_OPERANDS("Tz", pdfContext, 1); | 2393 EXPECT_OPERANDS("Tz", pdfContext, 1); |
2573 POP_NUMBER(pdfContext, scale); | 2394 POP_NUMBER(pdfContext, scale); |
2574 CHECK_PARAMETERS(); | 2395 CHECK_PARAMETERS(); |
2575 | 2396 |
2576 if (scale < 0) { | 2397 if (scale < 0) { |
2577 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, | 2398 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, |
2578 "scale must a positive real number", scale_obj, pdfContext); | 2399 "scale must a positive real number", scale_obj, pdfContext); |
2579 return kError_SkPdfResult; | 2400 return kError_SkPdfResult; |
2580 } | 2401 } |
2581 | 2402 |
2582 return kNYI_SkPdfResult; | 2403 return kNYI_SkPdfResult; |
2583 } | 2404 } |
2584 | 2405 |
2585 //render Tr Set the text rendering mode, T | 2406 //render Tr Set the text rendering mode, T |
2586 //mode, to render, which is an integer. Initial value: 0. | 2407 //mode, to render, which is an integer. Initial value: 0. |
2587 static SkPdfResult PdfOp_Tr(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 2408 static SkPdfResult PdfOp_Tr(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2588 EXPECT_OPERANDS("Tr", pdfContext, 1); | 2409 EXPECT_OPERANDS("Tr", pdfContext, 1); |
2589 POP_INTEGER(pdfContext, mode); | 2410 POP_INTEGER(pdfContext, mode); |
2590 CHECK_PARAMETERS(); | 2411 CHECK_PARAMETERS(); |
2591 | 2412 |
2592 if (mode < 0) { // TODO(edisonn): function/enums with supported modes | 2413 if (mode < 0) { // TODO(edisonn): function/enums with supported modes |
2593 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, | 2414 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, |
2594 "mode must a positive integer or 0", mode_obj, pdfContext); | 2415 "mode must a positive integer or 0", mode_obj, pdfContext); |
2595 return kError_SkPdfResult; | 2416 return kError_SkPdfResult; |
2596 } | 2417 } |
2597 | 2418 |
2598 return kNYI_SkPdfResult; | 2419 return kNYI_SkPdfResult; |
2599 } | 2420 } |
2600 //rise Ts Set the text rise, Trise, to rise, which is a number expressed in unsc
aled text space | 2421 //rise Ts Set the text rise, Trise, to rise, which is a number expressed in unsc
aled text space |
2601 //units. Initial value: 0. | 2422 //units. Initial value: 0. |
2602 static SkPdfResult PdfOp_Ts(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 2423 static SkPdfResult PdfOp_Ts(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2603 EXPECT_OPERANDS("Ts", pdfContext, 1); | 2424 EXPECT_OPERANDS("Ts", pdfContext, 1); |
2604 POP_NUMBER(pdfContext, rise); | 2425 POP_NUMBER(pdfContext, rise); |
2605 CHECK_PARAMETERS(); | 2426 CHECK_PARAMETERS(); |
2606 | 2427 |
2607 if (rise < 0) { | 2428 if (rise < 0) { |
2608 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, | 2429 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, |
2609 "rise must a positive real number", rise_obj, pdfContext); | 2430 "rise must a positive real number", rise_obj, pdfContext); |
2610 return kNYI_SkPdfResult; | 2431 return kNYI_SkPdfResult; |
2611 } | 2432 } |
2612 | 2433 |
2613 return kNYI_SkPdfResult; | 2434 return kNYI_SkPdfResult; |
2614 } | 2435 } |
2615 | 2436 |
2616 //wx wy d0 | 2437 //wx wy d0 |
2617 static SkPdfResult PdfOp_d0(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 2438 static SkPdfResult PdfOp_d0(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2618 EXPECT_OPERANDS("d0", pdfContext, 2); | 2439 EXPECT_OPERANDS("d0", pdfContext, 2); |
2619 POP_NUMBER(pdfContext, wy); | 2440 POP_NUMBER(pdfContext, wy); |
2620 POP_NUMBER(pdfContext, wx); | 2441 POP_NUMBER(pdfContext, wx); |
2621 CHECK_PARAMETERS(); | 2442 CHECK_PARAMETERS(); |
2622 | 2443 |
2623 if (wx < 0) { | 2444 if (wx < 0) { |
2624 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, | 2445 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, |
2625 "wx must a positive real number", wx_obj, pdfContext); | 2446 "wx must a positive real number", wx_obj, pdfContext); |
2626 return kError_SkPdfResult; | 2447 return kError_SkPdfResult; |
2627 } | 2448 } |
2628 | 2449 |
2629 if (wy < 0) { | 2450 if (wy < 0) { |
2630 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, | 2451 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kOutOfRange_SkPdfIssue, |
2631 "wy must a positive real number", wy_obj, pdfContext); | 2452 "wy must a positive real number", wy_obj, pdfContext); |
2632 return kError_SkPdfResult; | 2453 return kError_SkPdfResult; |
2633 } | 2454 } |
2634 | 2455 |
2635 return kNYI_SkPdfResult; | 2456 return kNYI_SkPdfResult; |
2636 } | 2457 } |
2637 | 2458 |
2638 //wx wy llx lly urx ury d1 | 2459 //wx wy llx lly urx ury d1 |
2639 static SkPdfResult PdfOp_d1(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 2460 static SkPdfResult PdfOp_d1(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2640 EXPECT_OPERANDS("d1", pdfContext, 6); | 2461 EXPECT_OPERANDS("d1", pdfContext, 6); |
2641 POP_NUMBER(pdfContext, ury); | 2462 POP_NUMBER(pdfContext, ury); |
2642 POP_NUMBER(pdfContext, urx); | 2463 POP_NUMBER(pdfContext, urx); |
2643 POP_NUMBER(pdfContext, lly); | 2464 POP_NUMBER(pdfContext, lly); |
2644 POP_NUMBER(pdfContext, llx); | 2465 POP_NUMBER(pdfContext, llx); |
2645 POP_NUMBER(pdfContext, wy); | 2466 POP_NUMBER(pdfContext, wy); |
2646 POP_NUMBER(pdfContext, wx); | 2467 POP_NUMBER(pdfContext, wx); |
2647 CHECK_PARAMETERS(); | 2468 CHECK_PARAMETERS(); |
2648 | 2469 |
2649 // TODO(edisonn): really silly quick way to remove warning | 2470 // TODO(edisonn): really silly quick way to remove warning |
2650 if (wx + wy + llx + lly + urx + ury) { | 2471 if (wx + wy + llx + lly + urx + ury) { |
2651 return kNYI_SkPdfResult; | 2472 return kNYI_SkPdfResult; |
2652 } | 2473 } |
2653 | 2474 |
2654 return kNYI_SkPdfResult; | 2475 return kNYI_SkPdfResult; |
2655 } | 2476 } |
2656 | 2477 |
2657 //name sh | 2478 //name sh |
2658 static SkPdfResult PdfOp_sh(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 2479 static SkPdfResult PdfOp_sh(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2659 EXPECT_OPERANDS("sh", pdfContext, 1); | 2480 EXPECT_OPERANDS("sh", pdfContext, 1); |
2660 POP_NAME(pdfContext, name); | 2481 POP_NAME(pdfContext, name); |
2661 CHECK_PARAMETERS(); | 2482 CHECK_PARAMETERS(); |
2662 | 2483 |
2663 if (name == NULL) { | 2484 if (name == NULL) { |
2664 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, name, | 2485 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, name, |
2665 SkPdfNativeObject::kName_PdfObjectType, pdfCon
text); | 2486 SkPdfNativeObject::kName_PdfObjectType, pdfCon
text); |
2666 return kError_SkPdfResult; | 2487 return kError_SkPdfResult; |
2667 } | 2488 } |
2668 | 2489 |
2669 return kNYI_SkPdfResult; | 2490 return kNYI_SkPdfResult; |
2670 } | 2491 } |
2671 | 2492 |
2672 //name Do | 2493 //name Do |
2673 static SkPdfResult PdfOp_Do(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 2494 static SkPdfResult PdfOp_Do(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2674 EXPECT_OPERANDS("Do", pdfContext, 1); | 2495 EXPECT_OPERANDS("Do", pdfContext, 1); |
2675 POP_NAME(pdfContext, name); | 2496 POP_NAME(pdfContext, name); |
2676 CHECK_PARAMETERS(); | 2497 CHECK_PARAMETERS(); |
2677 | 2498 |
2678 SkPdfDictionary* xObject = pdfContext->fGraphicsState.fResources->XObject(p
dfContext->fPdfDoc); | 2499 SkPdfDictionary* xObject = pdfContext->fGraphicsState.fResources->XObject(p
dfContext->fPdfDoc); |
2679 | 2500 |
2680 if (xObject == NULL) { | 2501 if (xObject == NULL) { |
2681 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingXObject_SkPdfIssue,
NULL, | 2502 SkPdfReport(kIgnoreError_SkPdfIssueSeverity, kMissingXObject_SkPdfIssue,
NULL, |
2682 pdfContext->fGraphicsState.fResources, pdfContext); | 2503 pdfContext->fGraphicsState.fResources, pdfContext); |
2683 return kIgnoreError_SkPdfResult; | 2504 return kIgnoreError_SkPdfResult; |
2684 } | 2505 } |
2685 | 2506 |
2686 SkPdfNativeObject* value = xObject->get(name); | 2507 SkPdfNativeObject* value = xObject->get(name); |
2687 value = pdfContext->fPdfDoc->resolveReference(value); | 2508 value = pdfContext->fPdfDoc->resolveReference(value); |
2688 | 2509 |
2689 return doXObject(pdfContext, canvas, value); | 2510 return doXObject(pdfContext, canvas, value); |
2690 } | 2511 } |
2691 | 2512 |
2692 //tag MP Designate a marked-content point. tag is a name object indicating the r
ole or | 2513 //tag MP Designate a marked-content point. tag is a name object indicating the r
ole or |
2693 //significance of the point. | 2514 //significance of the point. |
2694 static SkPdfResult PdfOp_MP(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 2515 static SkPdfResult PdfOp_MP(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2695 EXPECT_OPERANDS("MP", pdfContext, 1); | 2516 EXPECT_OPERANDS("MP", pdfContext, 1); |
2696 POP_OBJ(pdfContext, tag); | 2517 POP_OBJ(pdfContext, tag); |
2697 CHECK_PARAMETERS(); | 2518 CHECK_PARAMETERS(); |
2698 | 2519 |
2699 if (tag == NULL) { | 2520 if (tag == NULL) { |
2700 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag, | 2521 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag, |
2701 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); | 2522 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); |
2702 return kNYI_SkPdfResult; | 2523 return kNYI_SkPdfResult; |
2703 } | 2524 } |
2704 | 2525 |
2705 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "MP NYI", NULL
, NULL); | 2526 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "MP NYI", NULL
, NULL); |
2706 return kNYI_SkPdfResult; | 2527 return kNYI_SkPdfResult; |
2707 } | 2528 } |
2708 | 2529 |
2709 //tag properties DP Designate a marked-content point with an associated property
list. tag is a | 2530 //tag properties DP Designate a marked-content point with an associated property
list. tag is a |
2710 //name object indicating the role or significance of the point; properties is | 2531 //name object indicating the role or significance of the point; properties is |
2711 //either an inline dictionary containing the property list or a name object | 2532 //either an inline dictionary containing the property list or a name object |
2712 //associated with it in the Properties subdictionary of the current resource | 2533 //associated with it in the Properties subdictionary of the current resource |
2713 //dictionary (see Section 9.5.1, “Property Lists”). | 2534 //dictionary (see Section 9.5.1, “Property Lists”). |
2714 static SkPdfResult PdfOp_DP(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToken
Looper** looper) { | 2535 static SkPdfResult PdfOp_DP(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTok
enLooper** looper) { |
2715 EXPECT_OPERANDS("DP", pdfContext, 2); | 2536 EXPECT_OPERANDS("DP", pdfContext, 2); |
2716 POP_OBJ(pdfContext, properties); | 2537 POP_OBJ(pdfContext, properties); |
2717 POP_OBJ(pdfContext, tag); | 2538 POP_OBJ(pdfContext, tag); |
2718 CHECK_PARAMETERS(); | 2539 CHECK_PARAMETERS(); |
2719 | 2540 |
2720 if (tag == NULL) { | 2541 if (tag == NULL) { |
2721 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag, | 2542 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag, |
2722 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); | 2543 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); |
2723 return kNYI_SkPdfResult; | 2544 return kNYI_SkPdfResult; |
2724 } | 2545 } |
2725 | 2546 |
2726 if (properties == NULL) { | 2547 if (properties == NULL) { |
2727 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, propert
ies, | 2548 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, propert
ies, |
2728 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); | 2549 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); |
2729 return kNYI_SkPdfResult; | 2550 return kNYI_SkPdfResult; |
2730 } | 2551 } |
2731 | 2552 |
2732 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "DP NYI", NULL
, NULL); | 2553 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "DP NYI", NULL
, NULL); |
2733 return kNYI_SkPdfResult; | 2554 return kNYI_SkPdfResult; |
2734 } | 2555 } |
2735 | 2556 |
2736 //tag BMC Begin a marked-content sequence terminated by a balancing EMC operator
. | 2557 //tag BMC Begin a marked-content sequence terminated by a balancing EMC operator
. |
2737 //tag is a name object indicating the role or significance of the sequence. | 2558 //tag is a name object indicating the role or significance of the sequence. |
2738 static SkPdfResult PdfOp_BMC(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToke
nLooper** looper) { | 2559 static SkPdfResult PdfOp_BMC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTo
kenLooper** looper) { |
2739 EXPECT_OPERANDS("BMC", pdfContext, 1); | 2560 EXPECT_OPERANDS("BMC", pdfContext, 1); |
2740 POP_OBJ(pdfContext, tag); | 2561 POP_OBJ(pdfContext, tag); |
2741 CHECK_PARAMETERS(); | 2562 CHECK_PARAMETERS(); |
2742 | 2563 |
2743 if (tag == NULL) { | 2564 if (tag == NULL) { |
2744 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag, | 2565 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag, |
2745 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); | 2566 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); |
2746 return kNYI_SkPdfResult; | 2567 return kNYI_SkPdfResult; |
2747 } | 2568 } |
2748 | 2569 |
2749 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "BMC NYI", NUL
L, NULL); | 2570 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "BMC NYI", NUL
L, NULL); |
2750 return kNYI_SkPdfResult; | 2571 return kNYI_SkPdfResult; |
2751 } | 2572 } |
2752 | 2573 |
2753 //tag properties BDC Begin a marked-content sequence with an associated property
list, terminated | 2574 //tag properties BDC Begin a marked-content sequence with an associated property
list, terminated |
2754 //by a balancing EMCoperator. tag is a name object indicating the role or signif
icance of the | 2575 //by a balancing EMCoperator. tag is a name object indicating the role or signif
icance of the |
2755 // sequence; propertiesis either an inline dictionary containing the | 2576 // sequence; propertiesis either an inline dictionary containing the |
2756 //property list or a name object associated with it in the Properties subdiction
ary of the current | 2577 //property list or a name object associated with it in the Properties subdiction
ary of the current |
2757 //resource dictionary (see Section 9.5.1, “Property Lists”). | 2578 //resource dictionary (see Section 9.5.1, “Property Lists”). |
2758 static SkPdfResult PdfOp_BDC(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToke
nLooper** looper) { | 2579 static SkPdfResult PdfOp_BDC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTo
kenLooper** looper) { |
2759 EXPECT_OPERANDS("BDC", pdfContext, 2); | 2580 EXPECT_OPERANDS("BDC", pdfContext, 2); |
2760 POP_OBJ(pdfContext, properties); | 2581 POP_OBJ(pdfContext, properties); |
2761 POP_OBJ(pdfContext, tag); | 2582 POP_OBJ(pdfContext, tag); |
2762 CHECK_PARAMETERS(); | 2583 CHECK_PARAMETERS(); |
2763 | 2584 |
2764 if (tag == NULL) { | 2585 if (tag == NULL) { |
2765 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag, | 2586 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, tag, |
2766 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); | 2587 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); |
2767 return kNYI_SkPdfResult; | 2588 return kNYI_SkPdfResult; |
2768 } | 2589 } |
2769 | 2590 |
2770 if (properties == NULL) { | 2591 if (properties == NULL) { |
2771 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, propert
ies, | 2592 SkPdfReportUnexpectedType(kIgnoreError_SkPdfIssueSeverity, NULL, propert
ies, |
2772 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); | 2593 SkPdfNativeObject::_kObject_PdfObjectType, pdf
Context); |
2773 return kNYI_SkPdfResult; | 2594 return kNYI_SkPdfResult; |
2774 } | 2595 } |
2775 | 2596 |
2776 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "BDC NYI", NUL
L, NULL); | 2597 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "BDC NYI", NUL
L, NULL); |
2777 return kNYI_SkPdfResult; | 2598 return kNYI_SkPdfResult; |
2778 } | 2599 } |
2779 | 2600 |
2780 //— EMC End a marked-content sequence begun by a BMC or BDC operator. | 2601 //— EMC End a marked-content sequence begun by a BMC or BDC operator. |
2781 static SkPdfResult PdfOp_EMC(SkPdfContext* pdfContext, SkCanvas* canvas, PdfToke
nLooper** looper) { | 2602 static SkPdfResult PdfOp_EMC(SkPdfContext* pdfContext, SkCanvas* canvas, SkPdfTo
kenLooper** looper) { |
2782 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "EMC NYI", NUL
L, NULL); | 2603 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, "EMC NYI", NUL
L, NULL); |
2783 return kNYI_SkPdfResult; | 2604 return kNYI_SkPdfResult; |
2784 } | 2605 } |
2785 | 2606 |
| 2607 #include "SkPdfOps.h" |
| 2608 |
| 2609 SkTDict<PdfOperatorRenderer> gPdfOps(100); |
| 2610 |
2786 static void initPdfOperatorRenderes() { | 2611 static void initPdfOperatorRenderes() { |
2787 static bool gInitialized = false; | 2612 static bool gInitialized = false; |
2788 if (gInitialized) { | 2613 if (gInitialized) { |
2789 return; | 2614 return; |
2790 } | 2615 } |
2791 | 2616 |
2792 gPdfOps.set("q", PdfOp_q); | 2617 gPdfOps.set("q", PdfOp_q); |
2793 gPdfOps.set("Q", PdfOp_Q); | 2618 gPdfOps.set("Q", PdfOp_Q); |
2794 gPdfOps.set("cm", PdfOp_cm); | 2619 gPdfOps.set("cm", PdfOp_cm); |
2795 | 2620 |
(...skipping 87 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2883 | 2708 |
2884 class InitPdfOps { | 2709 class InitPdfOps { |
2885 public: | 2710 public: |
2886 InitPdfOps() { | 2711 InitPdfOps() { |
2887 initPdfOperatorRenderes(); | 2712 initPdfOperatorRenderes(); |
2888 } | 2713 } |
2889 }; | 2714 }; |
2890 | 2715 |
2891 InitPdfOps gInitPdfOps; | 2716 InitPdfOps gInitPdfOps; |
2892 | 2717 |
2893 void reportPdfRenderStats() { | |
2894 for (int i = 0 ; i < kCount_SkPdfResult; i++) { | |
2895 SkTDict<int>::Iter iter(gRenderStats[i]); | |
2896 const char* key; | |
2897 int value = 0; | |
2898 while ((key = iter.next(&value)) != NULL) { | |
2899 printf("%s: %s -> count %i\n", gRenderStatsNames[i], key, value); | |
2900 } | |
2901 } | |
2902 } | |
2903 | |
2904 SkPdfResult PdfMainLooper::consumeToken(PdfToken& token) { | |
2905 if (token.fType == kKeyword_TokenType && token.fKeywordLength < 256) | |
2906 { | |
2907 PdfOperatorRenderer pdfOperatorRenderer = NULL; | |
2908 if (gPdfOps.find(token.fKeyword, token.fKeywordLength, &pdfOperatorRende
rer) && | |
2909 pdfOperatorRenderer) { | |
2910 PdfTokenLooper* childLooper = NULL; | |
2911 // Main work is done by pdfOperatorRenderer(...) | |
2912 SkPdfResult result = pdfOperatorRenderer(fPdfContext, fCanvas, &chil
dLooper); | |
2913 | |
2914 int cnt = 0; | |
2915 gRenderStats[result].find(token.fKeyword, token.fKeywordLength, &cnt
); | |
2916 gRenderStats[result].set(token.fKeyword, token.fKeywordLength, cnt +
1); | |
2917 | |
2918 if (childLooper) { | |
2919 childLooper->setUp(this); | |
2920 childLooper->loop(); | |
2921 delete childLooper; | |
2922 } | |
2923 } else { | |
2924 int cnt = 0; | |
2925 gRenderStats[kUnsupported_SkPdfResult].find(token.fKeyword, | |
2926 token.fKeywordLength, | |
2927 &cnt); | |
2928 gRenderStats[kUnsupported_SkPdfResult].set(token.fKeyword, | |
2929 token.fKeywordLength, | |
2930 cnt + 1); | |
2931 } | |
2932 } | |
2933 else if (token.fType == kObject_TokenType) | |
2934 { | |
2935 fPdfContext->fObjectStack.push( token.fObject ); | |
2936 } | |
2937 else { | |
2938 // TODO(edisonn): store the keyword as a object, so we can track the loc
ation in file, | |
2939 // and report where the error was triggered | |
2940 SkPdfReport(kCodeWarning_SkPdfIssueSeverity, kNYI_SkPdfIssue, token.fKey
word, NULL, | |
2941 fPdfContext); | |
2942 return kIgnoreError_SkPdfResult; | |
2943 } | |
2944 return kOK_SkPdfResult; | |
2945 } | |
2946 | |
2947 void PdfMainLooper::loop() { | |
2948 PdfToken token; | |
2949 while (readToken(fTokenizer, &token)) { | |
2950 consumeToken(token); | |
2951 } | |
2952 } | |
2953 | |
2954 SkPdfResult PdfInlineImageLooper::consumeToken(PdfToken& token) { | 2718 SkPdfResult PdfInlineImageLooper::consumeToken(PdfToken& token) { |
2955 SkASSERT(false); | 2719 SkASSERT(false); |
2956 return kIgnoreError_SkPdfResult; | 2720 return kIgnoreError_SkPdfResult; |
2957 } | 2721 } |
2958 | 2722 |
2959 void PdfInlineImageLooper::loop() { | 2723 void PdfInlineImageLooper::loop() { |
2960 doXObject_Image(fPdfContext, fCanvas, fTokenizer->readInlineImage()); | 2724 doXObject_Image(fPdfContext, fCanvas, fTokenizer->readInlineImage()); |
2961 } | 2725 } |
2962 | 2726 |
2963 SkPdfResult PdfInlineImageLooper::done() { | 2727 SkPdfResult PdfInlineImageLooper::done() { |
2964 return kNYI_SkPdfResult; | 2728 return kNYI_SkPdfResult; |
2965 } | 2729 } |
2966 | 2730 |
2967 SkPdfResult PdfCompatibilitySectionLooper::consumeToken(PdfToken& token) { | 2731 SkPdfResult PdfCompatibilitySectionLooper::consumeToken(PdfToken& token) { |
2968 return fParent->consumeToken(token); | 2732 return fParent->consumeToken(token); |
2969 } | 2733 } |
2970 | 2734 |
2971 void PdfCompatibilitySectionLooper::loop() { | 2735 void PdfCompatibilitySectionLooper::loop() { |
2972 PdfOp_q(fPdfContext, fCanvas, NULL); | 2736 PdfOp_q(fPdfContext, fCanvas, NULL); |
2973 | 2737 |
2974 PdfToken token; | 2738 PdfToken token; |
2975 while (readToken(fTokenizer, &token)) { | 2739 while (readToken(fTokenizer, &token)) { |
2976 if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") ==
0) { | 2740 if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "BX") ==
0) { |
2977 PdfTokenLooper* looper = new PdfCompatibilitySectionLooper(); | 2741 SkPdfTokenLooper* looper = new PdfCompatibilitySectionLooper(); |
2978 looper->setUp(this); | 2742 looper->setUp(this); |
2979 looper->loop(); | 2743 looper->loop(); |
2980 delete looper; | 2744 delete looper; |
2981 } else { | 2745 } else { |
2982 if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EX"
) == 0) break; | 2746 if (token.fType == kKeyword_TokenType && strcmp(token.fKeyword, "EX"
) == 0) break; |
2983 fParent->consumeToken(token); | 2747 fParent->consumeToken(token); |
2984 } | 2748 } |
2985 } | 2749 } |
2986 | 2750 |
2987 PdfOp_Q(fPdfContext, fCanvas, NULL); | 2751 PdfOp_Q(fPdfContext, fCanvas, NULL); |
(...skipping 145 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3133 | 2897 |
3134 rect = SkRect::MakeWH(width, height); | 2898 rect = SkRect::MakeWH(width, height); |
3135 | 2899 |
3136 setup_bitmap(output, SkScalarCeilToInt(width), SkScalarCeilToInt(height)); | 2900 setup_bitmap(output, SkScalarCeilToInt(width), SkScalarCeilToInt(height)); |
3137 | 2901 |
3138 SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (*output))); | 2902 SkAutoTUnref<SkBaseDevice> device(SkNEW_ARGS(SkBitmapDevice, (*output))); |
3139 SkCanvas canvas(device); | 2903 SkCanvas canvas(device); |
3140 | 2904 |
3141 return renderer->renderPage(page, &canvas, rect); | 2905 return renderer->renderPage(page, &canvas, rect); |
3142 } | 2906 } |
OLD | NEW |