Basic support for Type3 Fonts in Pdf + various refactorings

experimental/PdfViewer/generate_code.py

 
 
 import sys
 
 import datatypes
-import pdfspec_autogen
+from autogen.pdfspec_autogen import *
 
 knowTypes = {
 '(any)': ['SkPdfObject*', 'ObjectFromDictionary', datatypes.CppNull(), 'true'],
 '(undefined)': ['SkPdfObject*', 'ObjectFromDictionary', datatypes.CppNull(), 'true'],
 '(various)': ['SkPdfObject*', 'ObjectFromDictionary', datatypes.CppNull(), 'true'],
-'array': ['SkPdfArray', 'ArrayFromDictionary', datatypes.PdfArrayNone(), 'ret->podofo()->GetDataType() == ePdfDataType_Array'],
+'array': ['SkPdfArray*', 'ArrayFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Array'],
 'boolean': ['bool', 'BoolFromDictionary', datatypes.PdfBoolean('false'), 'ret->podofo()->GetDataType() == ePdfDataType_Bool'],
 'date': ['SkPdfDate', 'DateFromDictionary', datatypes.PdfDateNever(), 'ret->podofo()->GetDataType() == ePdfDataType_Array'],
 'dictionary': ['SkPdfDictionary*', 'DictionaryFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Dictionary'],
 'function': ['SkPdfFunction', 'FunctionFromDictionary', datatypes.PdfFunctionNone(), 'ret->podofo()->GetDataType() == ePdfDataType_Reference'],
 'integer': ['long', 'LongFromDictionary', datatypes.PdfInteger(0), 'ret->podofo()->GetDataType() == ePdfDataType_Number'],
 'file_specification': ['SkPdfFileSpec', 'FileSpecFromDictionary', datatypes.FileSpecNone(), 'ret->podofo()->GetDataType() == ePdfDataType_Reference'],
 'name': ['std::string', 'NameFromDictionary', datatypes.PdfString('""'), 'ret->podofo()->GetDataType() == ePdfDataType_Name'],
 'tree': ['SkPdfTree*', 'TreeFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Reference'],
 'number': ['double', 'DoubleFromDictionary', datatypes.PdfNumber(0), 'ret->podofo()->GetDataType() == ePdfDataType_Real || ret->podofo()->GetDataType() == ePdfDataType_Number'],
-'rectangle': ['SkRect', 'SkRectFromDictionary', datatypes.PdfEmptyRect(), 'ret->podofo()->GetDataType() == ePdfDataType_Array'],
+'rectangle': ['SkRect*', 'SkRectFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Array && ret->podofo()->GetArray().GetLength() == 4'],
 'stream': ['SkPdfStream*', 'StreamFromDictionary',  datatypes.CppNull(), 'ret->podofo()->HasStream()'],
 'string': ['std::string', 'StringFromDictionary', datatypes.PdfString('""'), 'ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString'],
 'text': ['std::string', 'StringFromDictionary', datatypes.PdfString('""'), 'ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString'],
 'text string': ['std::string', 'StringFromDictionary', datatypes.PdfString('""'), 'ret->podofo()->GetDataType() == ePdfDataType_String || ret->podofo()->GetDataType() == ePdfDataType_HexString'],
+'matrix': ['SkMatrix*', 'SkMatrixFromDictionary', datatypes.CppNull(), 'ret->podofo()->GetDataType() == ePdfDataType_Array && ret->podofo()->GetArray().GetLength() == 4'],
 }
 
 
 class PdfField:
   def __init__(self, parent, name, abr):
     self.fParent = parent
     self.fName = name
     self.fAbr = abr
     
     self.fDefault = ''
@@ skipping 245 matching lines @@
     
     for name in self.fClassesNamesInOrder:
       cls = self.fClasses[name]
       enum = cls.fEnum
       
       fileClass = open('SkPdf' + cls.fName + '_autogen.h', 'w')
       fileClass.write('#ifndef __DEFINED__SkPdf' + cls.fName + '\n')
       fileClass.write('#define __DEFINED__SkPdf' + cls.fName + '\n')
       fileClass.write('\n')
 
+      fileClass.write('#include "SkPdfUtils.h"\n')
       fileClass.write('#include "SkPdfEnums_autogen.h"\n')
       fileClass.write('#include "SkPdfArray_autogen.h"\n')
       if cls.fBase != '':
         fileClass.write('#include "SkPdf' + cls.fBase + '_autogen.h"\n')
       fileClass.write('\n')
       
       if cls.fComment != '':
         fileClass.write('// ' + cls.fComment + '\n')
       
       if cls.fBase == '':
@@ skipping 18 matching lines @@
       for cc in cls.fCCPrivate:
         fileClass.write('  ' + cc + '\n')
 
       if cls.fBase == '':
         fileClass.write('protected:\n')
         fileClass.write('  const PdfMemDocument* fPodofoDoc;\n')
         fileClass.write('  const PdfObject* fPodofoObj;\n')
         fileClass.write('\n')
         fileClass.write('public:\n')
         fileClass.write('  SkPdf' + cls.fName + '(const PdfMemDocument* podofoDoc = NULL, const PdfObject* podofoObj = NULL) : fPodofoDoc(podofoDoc), fPodofoObj(podofoObj) {}\n')
+        fileClass.write('  SkPdf' + cls.fName + '(const SkPdf' + cls.fName + '& from) : fPodofoDoc(from.fPodofoDoc), fPodofoObj(from.fPodofoObj) {}\n')
+        fileClass.write('\n')
         fileClass.write('  const PdfMemDocument* doc() const { return fPodofoDoc;}\n')
         fileClass.write('  const PdfObject* podofo() const { return fPodofoObj;}\n')
       else:
         fileClass.write('public:\n')
         fileClass.write('  SkPdf' + cls.fName + '(const PdfMemDocument* podofoDoc = NULL, const PdfObject* podofoObj = NULL) : SkPdf' + cls.fBase + '(podofoDoc, podofoObj) {}\n')
         fileClass.write('\n')
+        fileClass.write('  SkPdf' + cls.fName + '(const SkPdf' + cls.fName + '& from) : SkPdf' + cls.fBase + '(from.fPodofoDoc, from.fPodofoObj) {}\n')
+        fileClass.write('\n')
+      
       
       #check required fieds, also, there should be an internal_valid() manually wrote for complex
       # situations
       # right now valid return true      
       fileClass.write('  virtual bool valid() const {return true;}\n')
       fileClass.write('\n')
       
       fileClass.write('  SkPdf' + cls.fName + '& operator=(const SkPdf' + cls.fName + '& from) {this->fPodofoDoc = from.fPodofoDoc; this->fPodofoObj = from.fPodofoObj; return *this;}\n')
       fileClass.write('\n')
       
@@ skipping 144 matching lines @@
     fileMapper.write('};\n') 
     fileMapper.write('\n')
     
     fileMapper.write('#endif  // __DEFINED__SkPdfPodofoMapper\n')
     fileMapper.close()
     
     return
 
 def generateCode():
   global fileHeaders 
+  global knowTypes
 
   fileHeaders = open('SkPdfHeaders_autogen.h', 'w')
   fileHeaders.write('#ifndef __DEFINED__SkPdfHeaders\n')
   fileHeaders.write('#define __DEFINED__SkPdfHeaders\n')
   fileHeaders.write('\n')
   
   fileHeaders.write('#include "SkPdfEnums_autogen.h"\n')
 
   manager = PdfClassManager()
   
@@ skipping 18 matching lines @@
                              .carbonCopyPublic('const int size() const {return fPodofoObj->GetArray().GetSize();}')\
                              .carbonCopyPublic('SkPdfObject* operator[](int i) const { SkPdfObject* ret = NULL;  skpdfmap(*fPodofoDoc, fPodofoObj->GetArray()[i], &ret);  return ret; }')\
   
   manager.addClass('String').check('podofoObj.GetDataType() == ePdfDataType_String || podofoObj.GetDataType() == ePdfDataType_HexString')\
                              .carbonCopyPublic('const std::string& value() const {return fPodofoObj->GetString().GetStringUtf8();}')
                              
   manager.addClass('HexString', 'String').check('podofoObj.GetDataType() == ePdfDataType_HexString')\
                              .carbonCopyPublic('const std::string& value() const {return fPodofoObj->GetString().GetStringUtf8();}')
   
   manager.addClass('Dictionary').check('podofoObj.GetDataType() == ePdfDataType_Dictionary')\
-                                .carbonCopyPublic('const SkPdfObject get(const char* dictionaryKeyName) const {return SkPdfObject(fPodofoDoc, resolveReferenceObject(fPodofoDoc, fPodofoObj->GetDictionary().GetKey(PdfName(dictionaryKeyName))));}')\
-                                .carbonCopyPublic('SkPdfObject get(const char* dictionaryKeyName) {return SkPdfObject(fPodofoDoc, resolveReferenceObject(fPodofoDoc, fPodofoObj->GetDictionary().GetKey(PdfName(dictionaryKeyName))));}')\
+                                .carbonCopyPublic('SkPdfObject* get(const char* dictionaryKeyName) const {return new SkPdfObject(fPodofoDoc, resolveReferenceObject(fPodofoDoc, fPodofoObj->GetDictionary().GetKey(PdfName(dictionaryKeyName))));}')\
+                                .carbonCopyPublic('SkPdfObject* get(const char* dictionaryKeyName) {return new SkPdfObject(fPodofoDoc, resolveReferenceObject(fPodofoDoc, fPodofoObj->GetDictionary().GetKey(PdfName(dictionaryKeyName))));}')\
 
   manager.addClass('Stream')  # attached to a dictionary in podofo
   
   
   # these classes are not explicitely backed by a table in the pdf spec
   manager.addClass('XObjectDictionary', 'Dictionary')
   
   manager.addClass('FontDictionary', 'Dictionary')
   
   manager.addClass('TrueTypeFontDictionary', 'Type1FontDictionary')\
           .required('NULL')\
           .field('Subtype')\
           .name('Subtype')\
           .type('name')\
           .comment('')\
           .must([datatypes.PdfName('TrueType')])\
           .done().done()\
   
-  pdfspec_autogen.buildPdfSpec(manager)  
+  
+  addDictionaryTypesTo(knowTypes)
+  buildPdfSpec(manager)  
 
   manager.addClass('MultiMasterFontDictionary', 'Type1FontDictionary')\
           .required('NULL')\
           .field('Subtype')\
           .name('Subtype')\
           .type('name')\
           .comment('')\
           .must([datatypes.PdfName('MMType1')])\
           .done().done()\
 
 
   manager.write()
   
   fileHeaders.write('#endif  // __DEFINED__SkPdfHeaders\n')
   fileHeaders.close()
   
   return 1
 
 if '__main__' == __name__:
   sys.exit(generateCode())