Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1016)

Side by Side Diff: experimental/PdfViewer/src/SkPdfRenderer.cpp

Issue 79933003: Restructuring of PdfViewer code. (Closed) Base URL: https://skia.googlecode.com/svn/trunk
Patch Set: Created 7 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698