Deal with ca and CA transparency operators in pdf. add comments to generated classes.

experimental/PdfViewer/pdf_viewer_main.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkCanvas.h"
 #include "SkDevice.h"
+#include "SkForceLinking.h"
 #include "SkGraphics.h"
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
 #include "SkOSFile.h"
 #include "SkPicture.h"
 #include "SkStream.h"
 #include "SkTypeface.h"
 #include "SkTArray.h"
 #include "picture_utils.h"
 
 #include <iostream>
 #include <cstdio>
 #include <stack>
 
 #include "podofo.h"
 using namespace PoDoFo;
 
+__SK_FORCE_IMAGE_DECODER_LINKING;
+
 const PdfObject* resolveReferenceObject(const PdfMemDocument* pdfDoc,
                                   const PdfObject* obj,
                                   bool resolveOneElementArrays = false);
 
 bool LongFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         long* data);
 
@@ skipping 132 matching lines @@
 bool FunctionFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfFunction* data) {return false;}
 
 
 
 /*
  * TODO(edisonn):
- * - encapsulate podofo in the pdf api so the skpdf does not know anything about podofo
+ * - encapsulate podofo in the pdf api so the skpdf does not know anything about podofo ... in progress
  * - ASAP so skp -> pdf -> png looks great
- * - load gs/ especially smask and already known prop (skp)
- * - use transparency (I think ca and CA ops) (skp)
- * - all font types
- * - word spacing
- * - load font for baidu.pdf
- * - load font for youtube.pdf
+ * - load gs/ especially smask and already known prop (skp)...
+ * - all font types and all ppdf font features
+ *      - word spacing
+ *      - load font for baidu.pdf
+ *      - load font for youtube.pdf
+ *      - parser for pdf from the definition already available in pdfspec_autogen.py
+ * - wrapper on classes for customizations? e.g.
+ * SkPdfPageObjectVanila - has only the basic loaders/getters
+ * SkPdfPageObject : public SkPdfPageObjectVanila, extends, and I can add customizations here
+ * need to find a nice object model for all this with constructors and factories
+ * - deal with inheritable automatically ?
+ * - deal with specific type in spec directly, add all dictionary types to known types
 */
 
 //#define PDF_TRACE
 //#define PDF_TRACE_DIFF_IN_PNG
 //#define PDF_DEBUG_NO_CLIPING
 //#define PDF_DEBUG_NO_PAGE_CLIPING
 //#define PDF_DEBUG_3X
 
 // TODO(edisonn): move in trace util.
 #ifdef PDF_TRACE
@@ skipping 66 matching lines @@
                   SkDoubleToScalar(0),
                   SkDoubleToScalar(1));
 
     return matrix;
 }
 
 // TODO(edisonn): better class design.
 struct PdfColorOperator {
     std::string fColorSpace;  // TODO(edisonn): use SkString
     SkColor fColor;
+    double fOpacity;  // ca or CA
     // TODO(edisonn): add here other color space options.
 
     void setRGBColor(SkColor color) {
         // TODO(edisonn): ASSERT DeviceRGB is the color space.
         fColor = color;
     }
     // TODO(edisonn): double check the default values for all fields.
-    PdfColorOperator() : fColor(SK_ColorBLACK) {}
+    PdfColorOperator() : fColor(SK_ColorBLACK), fOpacity(1) {}
+
+    void applyGraphicsState(SkPaint* paint) {
+        paint->setColor(SkColorSetA(fColor, fOpacity * 255));
+    }
+
 };
 
 // TODO(edisonn): better class design.
 struct PdfGraphicsState {
     SkMatrix            fMatrix;
     SkMatrix            fMatrixTm;
     SkMatrix            fMatrixTlm;
 
     double              fCurPosX;
     double              fCurPosY;
@@ skipping 28 matching lines @@
         fCurFont      = NULL;
         fMatrix       = SkMatrix::I();
         fMatrixTm     = SkMatrix::I();
         fMatrixTlm    = SkMatrix::I();
         fPathClosed   = true;
         fLineWidth    = 0;
         fTextLeading  = 0;
         fWordSpace    = 0;
         fCharSpace    = 0;
         fHasClipPathToApply = false;
-        fResources = NULL;
+        fResources    = NULL;
+    }
+
+    void applyGraphicsState(SkPaint* paint, bool stroking) {
+        if (stroking) {
+            fStroking.applyGraphicsState(paint);
+        } else {
+            fNonStroking.applyGraphicsState(paint);
+        }
+
+        // TODO(edisonn): get this from pdfContext->options,
+        // or pdfContext->addPaintOptions(&paint);
+        paint->setAntiAlias(true);
+
+        // TODO(edisonn): dashing, miter, ...
+        paint->setStrokeWidth(SkDoubleToScalar(fLineWidth));
     }
 };
 
 // TODO(edisonn): better class design.
 struct PdfInlineImage {
     std::map<std::string, std::string> fKeyValuePairs;
     std::string fImageData;
 
 };
 
@@ skipping 416 matching lines @@
 
     SkPaint paint;
     // TODO(edisonn): when should fCurFont->GetFontSize() used? When cur is fCurFontSize == 0?
     // Or maybe just not call setTextSize at all?
     if (pdfContext->fGraphicsState.fCurFontSize != 0) {
         paint.setTextSize(SkDoubleToScalar(pdfContext->fGraphicsState.fCurFontSize));
     }
     if (fCurFont->GetFontScale() != 0) {
         paint.setTextScaleX(SkFloatToScalar(fCurFont->GetFontScale() / 100.0));
     }
-    paint.setColor(pdfContext->fGraphicsState.fNonStroking.fColor);
+
+    pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
 
     paint.setTypeface(SkTypefaceFromPdfFont(fCurFont));
 
     paint.setAntiAlias(true);
     // TODO(edisonn): paint.setStyle(...);
 
     canvas->save();
     SkMatrix matrix = pdfContext->fGraphicsState.fMatrixTm;
 
 #if 0
@@ skipping 99 matching lines @@
 bool LongFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         long* data) {
     const PdfObject* value = resolveReferenceObject(pdfDoc,
                                               dict.GetKey(PdfName(key)));
 
     if (value == NULL || !value->IsNumber()) {
         return false;
     }
+    if (data == NULL) {
+        return true;
+    }
 
     *data = value->GetNumber();
     return true;
 }
 
 bool LongFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         long* data) {
     if (LongFromDictionary(pdfDoc, dict, key, data)) return true;
     if (abr == NULL || *abr == '\0') return false;
     return LongFromDictionary(pdfDoc, dict, abr, data);
 }
 
 bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
                           const PdfDictionary& dict,
                           const char* key,
                           double* data) {
     const PdfObject* value = resolveReferenceObject(pdfDoc,
                                               dict.GetKey(PdfName(key)));
 
-    if (value == NULL || !value->IsReal()) {
+    if (value == NULL || (!value->IsReal() && !value->IsNumber())) {
         return false;
     }
+    if (data == NULL) {
+        return true;
+    }
 
     *data = value->GetReal();
     return true;
 }
 
 bool DoubleFromDictionary(const PdfMemDocument* pdfDoc,
                           const PdfDictionary& dict,
                           const char* key,
                           const char* abr,
                           double* data) {
     if (DoubleFromDictionary(pdfDoc, dict, key, data)) return true;
     if (abr == NULL || *abr == '\0') return false;
     return DoubleFromDictionary(pdfDoc, dict, abr, data);
 }
 
 
 bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         bool* data) {
     const PdfObject* value = resolveReferenceObject(pdfDoc,
                                               dict.GetKey(PdfName(key)));
 
     if (value == NULL || !value->IsBool()) {
         return false;
     }
+    if (data == NULL) {
+        return true;
+    }
 
     *data = value->GetBool();
     return true;
 }
 
 bool BoolFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         bool* data) {
     if (BoolFromDictionary(pdfDoc, dict, key, data)) return true;
     if (abr == NULL || *abr == '\0') return false;
     return BoolFromDictionary(pdfDoc, dict, abr, data);
 }
 
 bool NameFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         std::string* data) {
     const PdfObject* value = resolveReferenceObject(pdfDoc,
                                               dict.GetKey(PdfName(key)),
                                               true);
     if (value == NULL || !value->IsName()) {
         return false;
     }
+    if (data == NULL) {
+        return true;
+    }
 
     *data = value->GetName().GetName();
     return true;
 }
 
 bool NameFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         std::string* data) {
     if (NameFromDictionary(pdfDoc, dict, key, data)) return true;
     if (abr == NULL || *abr == '\0') return false;
     return NameFromDictionary(pdfDoc, dict, abr, data);
 }
 
 bool StringFromDictionary(const PdfMemDocument* pdfDoc,
                           const PdfDictionary& dict,
                           const char* key,
                           std::string* data) {
     const PdfObject* value = resolveReferenceObject(pdfDoc,
                                               dict.GetKey(PdfName(key)),
                                               true);
     if (value == NULL || (!value->IsString() && !value->IsHexString())) {
         return false;
     }
+    if (data == NULL) {
+        return true;
+    }
 
     *data = value->GetString().GetString();
     return true;
 }
 
 bool StringFromDictionary(const PdfMemDocument* pdfDoc,
                           const PdfDictionary& dict,
                           const char* key,
                           const char* abr,
                           std::string* data) {
     if (StringFromDictionary(pdfDoc, dict, key, data)) return true;
     if (abr == NULL || *abr == '\0') return false;
     return StringFromDictionary(pdfDoc, dict, abr, data);
 }
 
 bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
                               const PdfDictionary& dict,
                               const char* key,
                               SkPdfDictionary** data) {
     const PdfObject* value = resolveReferenceObject(pdfDoc,
                                               dict.GetKey(PdfName(key)),
                                               true);
     if (value == NULL || !value->IsDictionary()) {
         return false;
     }
+    if (data == NULL) {
+        return true;
+    }
 
     return PodofoMapper::map(*pdfDoc, *value, (SkPdfObject**)data);
 }
 
 bool DictionaryFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfDictionary** data) {
     if (DictionaryFromDictionary(pdfDoc, dict, key, data)) return true;
     if (abr == NULL || *abr == '\0') return false;
     return DictionaryFromDictionary(pdfDoc, dict, abr, data);
 }
 
 template <typename T>
 bool DictionaryFromDictionary2(const PdfMemDocument* pdfDoc,
                               const PdfDictionary& dict,
                               const char* key,
                               SkPdfDictionary** data) {
     const PdfObject* value = resolveReferenceObject(pdfDoc,
                                               dict.GetKey(PdfName(key)),
                                               true);
     if (value == NULL || !value->IsDictionary()) {
         return false;
     }
 
+    if (data == NULL) {
+        return true;
+    }
+
     return PodofoMapper::map(*pdfDoc, *value, (T**)data);
 }
 
 template <typename T>
 bool DictionaryFromDictionary2(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         T** data) {
     if (DictionaryFromDictionary2<T>(pdfDoc, dict, key, data)) return true;
     if (abr == NULL || *abr == '\0') return false;
     return DictionaryFromDictionary2<T>(pdfDoc, dict, abr, data);
 }
 
 bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
                           const PdfDictionary& dict,
                           const char* key,
                           SkPdfObject** data) {
     const PdfObject* value = resolveReferenceObject(pdfDoc,
                                               dict.GetKey(PdfName(key)),
                                               true);
     if (value == NULL) {
         return false;
     }
+    if (data == NULL) {
+        return true;
+    }
     return PodofoMapper::map(*pdfDoc, *value, data);
 }
 
 bool ObjectFromDictionary(const PdfMemDocument* pdfDoc,
                         const PdfDictionary& dict,
                         const char* key,
                         const char* abr,
                         SkPdfObject** data) {
     if (ObjectFromDictionary(pdfDoc, dict, key, data)) return true;
     if (abr == NULL || *abr == '\0') return false;
@@ skipping 232 matching lines @@
     canvas->save();
     canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
     SkRect dst = SkRect::MakeXYWH(SkDoubleToScalar(0.0), SkDoubleToScalar(0.0), SkDoubleToScalar(1.0), SkDoubleToScalar(1.0));
 
     if (sMask.empty()) {
         canvas->drawBitmapRect(image, dst, NULL);
     } else {
         canvas->saveLayer(&dst, NULL);
         canvas->drawBitmapRect(image, dst, NULL);
         SkPaint xfer;
+        pdfContext->fGraphicsState.applyGraphicsState(&xfer, false);
         xfer.setXfermodeMode(SkXfermode::kSrcOut_Mode); // SkXfermode::kSdtOut_Mode
         canvas->drawBitmapRect(sMask, dst, &xfer);
         canvas->restore();
     }
 
     canvas->restore();
 
     return kPartial_PdfResult;
 }
 
@@ skipping 266 matching lines @@
     pdfContext->fGraphicsState.fMatrixTm.preConcat(matrix);
     pdfContext->fGraphicsState.fMatrixTlm.preConcat(matrix);
 
     return kPartial_PdfResult;
 }
 
 PdfResult PdfOp_TD(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     double ty = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
     double tx = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
 
+    // TODO(edisonn): Create factory methods or constructors so podofo is hidden
     PdfObject _ty(PdfVariant(-ty));
     pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc.podofo(), &_ty));
 
     PdfOp_TL(pdfContext, canvas, looper);
 
-    PdfObject vtx(PdfVariant(-(-tx)));  // TODO(edisonn) Hmm, the compiler thinks I have here a function pointer if we use (tx), but not -(-tx)
+    PdfObject vtx(PdfVariant(-(-tx)));  // TODO(edisonn): Hmm, the compiler thinks I have here a function pointer if we use (tx), but not -(-tx)
     pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc.podofo(), &vtx));
 
     PdfObject vty(PdfVariant(-(-ty)));
     pdfContext->fObjectStack.push(new SkPdfNumber(&pdfContext->fPdfDoc.podofo(), &vty));
 
     return PdfOp_Td(pdfContext, canvas, looper);
 }
 
 PdfResult PdfOp_Tm(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     double f = pdfContext->fObjectStack.top()->asNumber()->value(); pdfContext->fObjectStack.pop();
@@ skipping 162 matching lines @@
     SkPath path = pdfContext->fGraphicsState.fPath;
 
     if (close) {
         path.close();
     }
 
     canvas->setMatrix(pdfContext->fGraphicsState.fMatrix);
 
     SkPaint paint;
 
-    // TODO(edisonn): get this from pdfContext->options,
-    // or pdfContext->addPaintOptions(&paint);
-    paint.setAntiAlias(true);
-
-    // TODO(edisonn): dashing, miter, ...
-
-//    path.transform(pdfContext->fGraphicsState.fMatrix);
-//    path.transform(pdfContext->fOriginalMatrix);
-
     SkPoint line[2];
     if (fill && !stroke && path.isLine(line)) {
         paint.setStyle(SkPaint::kStroke_Style);
-        paint.setColor(pdfContext->fGraphicsState.fNonStroking.fColor);
+
+        pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
         paint.setStrokeWidth(SkDoubleToScalar(0));
+
         canvas->drawPath(path, paint);
     } else {
         if (fill) {
             paint.setStyle(SkPaint::kFill_Style);
             if (evenOdd) {
                 path.setFillType(SkPath::kEvenOdd_FillType);
             }
-            paint.setColor(pdfContext->fGraphicsState.fNonStroking.fColor);
+
+            pdfContext->fGraphicsState.applyGraphicsState(&paint, false);
+
             canvas->drawPath(path, paint);
         }
 
         if (stroke) {
             paint.setStyle(SkPaint::kStroke_Style);
-            paint.setColor(pdfContext->fGraphicsState.fStroking.fColor);
-            paint.setStrokeWidth(SkDoubleToScalar(pdfContext->fGraphicsState.fLineWidth));
+
+            pdfContext->fGraphicsState.applyGraphicsState(&paint, true);
+
             path.setFillType(SkPath::kWinding_FillType);  // reset it, just in case it messes up the stroke
             canvas->drawPath(path, paint);
         }
     }
 
     pdfContext->fGraphicsState.fPath.reset();
     // todo zoom ... other stuff ?
 
     if (pdfContext->fGraphicsState.fHasClipPathToApply) {
 #ifndef PDF_DEBUG_NO_CLIPING
@@ skipping 456 matching lines @@
 
 #ifdef PDF_TRACE
 //    value->ToString(str);
 //    printf("gs object value: %s\n", str.c_str());
 #endif
 
     SkPdfGraphicsStateDictionary* gs = NULL;
     PodofoMapper::map(value, &gs);
 
     // TODO(edisonn): now load all those properties in graphic state.
+    if (gs == NULL) {
+        return kIgnoreError_PdfResult;
+    }
+
+    if (gs->has_CA()) {
+        pdfContext->fGraphicsState.fStroking.fOpacity = gs->CA();
+    }
+
+    if (gs->has_ca()) {
+        pdfContext->fGraphicsState.fNonStroking.fOpacity = gs->ca();
+    }
+
+    if (gs->has_LW()) {
+        pdfContext->fGraphicsState.fLineWidth = gs->LW();
+    }
+
+
 
     return kNYI_PdfResult;
 }
 
 //charSpace Tc Set the character spacing, Tc
 //, to charSpace, which is a number expressed in unscaled text space units. Character spacing is used by the Tj, TJ, and ' operators.
 //Initial value: 0.
 PdfResult PdfOp_Tc(PdfContext* pdfContext, SkCanvas* canvas, PdfTokenLooper** looper) {
     double charSpace = pdfContext->fObjectStack.top()->asNumber()->value();     pdfContext->fObjectStack.pop();
     pdfContext->fGraphicsState.fCharSpace = charSpace;
@@ skipping 686 matching lines @@
     }
 
     return 0;
 }
 
 #if !defined SK_BUILD_FOR_IOS
 int main(int argc, char * const argv[]) {
     return tool_main(argc, (char**) argv);
 }
 #endif