def __validateXObjectDictionary(self, dict, id): if literal_name(dict.get("Subtype")) == "Form": # 6.2.5 if dict.get("Ref") != None: # 6.2.6 self.__write("XObject dictionary " + str(id) + " is a reference XObject") if dict.get("OPI") != None: self.__write("Form XObject dictionary " + str(id) + " contains OPI entry") # TODO: NOTE ale w reference 3 nie ma nic o Subtype2 i PS if dict.get("Subtype2") != None: if literal_name(dict.get("Subtype2")) == "PS": self.__write("Form XObject dictionary " + str(id) + " contains" + "Subtype2 entry with PS value") if dict.get("PS") != None: self.__write("Form XObject dictionary " + str(id) + " contains PS entry") if dict.get("Group") != None: # 6.4 groupDict = dict_value(dict.get("Group")) if literal_name(groupDict.get("S")) == "Transparency": self.__write( "Form XObject dictionary " + str(id) + "contains Group entry which S attribute value" + " id /Transparency") elif literal_name(dict.get("Subtype")) == "PS": # 6.2.7 self.__write("Document contains PostScript XObject " + str(id)) elif literal_name(dict.get("Subtype")) == "Image": self.__validateImageDictionary(dict, str(id))
def validate(self, fileName): self.__loadDocument(fileName) self.__write("GLOBAL:") self.__validateDocumentCatalog(self.__doc.catalog) j = 0 for p in self.__doc.get_pages(): j += 1 self.__write("PAGE " + str(j) + ":", error=False) images = dict_value(p.resources.get("XObject")) for (k, v) in images.iteritems(): self.__validateXObjectDictionary(dict_value(v), literal_name(k)) gstates = dict_value(p.resources.get("ExtGState")) for (k, v) in gstates.iteritems(): self.__validateGraphicsStateParameterDictionary( dict_value(v), literal_name(k)) # TODO: V czy w ten sposob sprawdzimy wszystkie wzorce o typie 2? patterns = dict_value(p.resources.get("Pattern")) for (k, v) in patterns.iteritems(): self.__validatePattern(dict_value(v), literal_name(k)) i = -1 for a in list_value(p.annots): i += 1 self.__validateAnnotationDictionary( dict_value(a), str(i) + " on page " + p.pageid) # TODO: V powinno byc sprawdzane, czy font jest uzywany (p. 6.3.4) fonts = dict_value(p.resources.get("Font")) for (k, v) in fonts.iteritems(): self.__validateFont(dict_value(v), literal_name(k)) self.__interp.process_page(p)
def setEncoding(self, enc): #self.__control.SetInsertionPoint(0) #self.__control.Clear() self.__mode = "Encoding" #self.__object = enc dEncoding = dict_value2(enc.get("Encoding")) differences = list_value(enc.get("Differences")) if dEncoding == None: nEncoding = literal_name(enc.get("Encoding")) if dEncoding == None: self.__control.WriteText("Base encoding: " + nEncoding + "\n") else: self.__colorSpace = dEncoding self.__control.BeginTextColour("#0000ff") self.__control.BeginUnderline() self.__control.BeginURL("0") self.__control.WriteText("Encoding") self.__control.EndURL() self.__control.EndUnderline() self.__control.EndTextColour() self.__control.WriteText("Differences:\n") code = 0 for el in differences: if isinstance(el, int): code = el else: self.__control.WriteText("\t" + str(code) + ": " + literal_name(el) + "\n") code += 1 self.__control.ShowPosition(0)
def __validateAction(self, action, id): # 6.6 # 6.6.1 if literal_name(action.get("S")) in [ "Launch", "Sound", "Movie", "ResetForm", "ImportData", "JavaScript", "set-state", "no-op" ]: self.__write("Action " + str(id) + " has type " + literal_name(action.get("S")) + ", which is not permitted") if literal_name(action.get("S")) == "Named" and not literal_name( action.get("N")) in [ "NextPage", "PrevPage", "LastPage", "FirstPage" ]: self.__write("Named action " + str(id) + " has name " + literal_name(action.get("N")) + ", which is not permitted")
def __validateAnnotationDictionary(self, dict, id): # 6.5 if not literal_name(dict.get("Subtype")) in [ "Text", "Link", "FreeText", "Line", "Square", "Circle", "Highlight", "Underline", "Squiggly", "StrikeOut", "Stamp", "Ink", "Popup", "Widget", "PrinterMark", "TrapNet" ]: self.__write("Annotation dictionary " + str(id) + "contains invalid" + " Subtype entry") if dict.get("CA") != None: if num_value(dict.get("CA")) != 1.0: self.__write("Annotation dictionary " + str(id) + " contains CA " + "entry which value isn't 1.0") if dict.get("F") != None: self.__write("Annotation dictionary " + str(id) + " contains F entry") if literal_name(dict.get("Subtype")) == "Widget": self.__validateWidgetAnnotation(dict, id) else: if dict.get("A") != None: self.__validateAction(dict_value(dict.get("A")), "in annotation " + str(id))
def __validateImageDiciotnary(self, dict, id): # 6.2.4 if dict.get("Alternates") != None: self.__write("Image dictionary " + str(id) + " contains Alternates entry") if dict.get("OPI") != None: self.__write("Image dictionary " + str(id) + " contains OPI entry") if dict.get("Interpolation") != None: if bool(dict.get("Interpolation")) == True: self.__write("Image dictionary " + str(id) + " contains Interpolate entry with value true") if dict.get("Intent") != None: self.__validateRenderingIntent( literal_name(dict.get("Intent")), "Image dictionary " + str(id) + " contains Intent entry with value " + literal_name(dict.get("Intent")) + ".") if dict.get("SMask") != None: # 6.4 TODO: NOTE ale w Image XObject nie moze byc name if literal_name(dict.get("SMask")) != "None": self.__write("Image dictionary " + str(id) + " contains SMask " + "entry which value isn't /None")
def __validateGraphicsStateParameterDictionary(self, dict, id): # 6.2.8 if dict.get("TR") != None: self.__write("Graphics state parameter dictionary " + str(id) + " contains TR entry") if dict.get("TR2") != None: if literal_name(dict.get("TR2")) != "Default": # TODO: X wypisac wartosc i wogole zrobic jakies funkcje # sprawdzajace typ obiektu PDFowego self.__write( "Graphics state parameter dictionary " + str(id) + " contains TR2 entry with value other than /Default") if dict.get("RI") != None: self.__validateRenderingIntent( literal_name(dict.get("Intent")), "Graphics state parameter " + "dictionary " + str(id) + " contains RI" + " entry with value " + literal_name(dict.get("Intent")) + ".") if dict.get("SMask") != None: # 6.4 if literal_name(dict.get("SMask")) != "None": self.__write("Image dictionary " + str(id) + " contains SMask " + "entry which value isn't /None") if dict.get("BM") != None: # 6.4 if not literal_name(dict.get("BM")) in ["Normal", "Compatible"]: self.__write("Image dictionary " + str(id) + " contains BM " + "entry which value isn't /Normal or /Compatible") if dict.get("CA") != None: # 6.4 if num_value(dict.get("CA")) != 1.0: self.__write("Image dictionary " + str(id) + " contains CA " + "entry which value isn't 1.0") if dict.get("ca") != None: # 6.4 if num_value(dict.get("ca")) != 1.0: self.__write("Image dictionary " + str(id) + " contains ca " + "entry which value isn't 1.0")
def __validateFont(self, font, id): # 6.3 if literal_name(font.get("Subtype")) == "Type0": self.__warning("Handling of Type0 fonts unimplemented") # 6.3.4 TODO: V sprawdzic czy font jest uzywany (patrz NOTE1 na nastepnej stronie) desc = dict_value_none(font.get("FontDescriptor")) if desc == None and literal_name( font.get("Subtype")) in ["TrueType", "Type1", "MMType1"]: self.__write("Font " + str(id) + " does not have FontDescriptor") if literal_name(font.get("Subtype")) == "TrueType": if desc != None and desc.get("FontFile2") == None: self.__write("Font " + str(id) + " does not have embedded file") if literal_name(font.get("Subtype")) in ["Type1", "MMType1"]: if desc != None and desc.get("FontFile1") == None: if desc != None and desc.get("FontFile3") == None: self.__write("Font " + str(id) + " does not have embedded file") # 6.3.5 if literal_name(font.get("Subtype")) == "Type1": # TODO: MMType1 tez? if isSubsetName(literal_name(font.get("BaseFont"))): if desc != None and desc.get("CharSet") == None: self.__write( "Font " + str(id) + " is Type1 font subset and does not contain CharSet") # 6.3.7 if literal_name(font.get("Subtype")) == "TrueType": if desc != None and desc.get("Flags") & 0x20 != 0: # non-symbolic if not literal_name(font.get("Encoding")) in [ "MacRomanEncoding", "WinAnsiEncoding" ]: self.__write( "TrueType font " + str(id) + " is non-symbolic and its" + " encoding is different than MacRomanEncoding or " + "WinAnsiEncoding") elif desc != None and desc.get("Flags") & 0x4 != 0: # symbolic if font.get("Encoding") != None: self.__write("TrueType font " + str(id) + " is symbolic and it" + " have Encoding entry in font dictionary") # 6.3.8 if not self.__levelb: if not literal_name(font.get("Encoding")) in [ "WinAnsiEncoding", "MacRomanEncoding", "MacExpertEncoding" ]: check = False if literal_name(font.get("Subtype")) in ["Type1", "MMType1"]: if desc == None: check = True else: set = str_value(desc.get("CharSet")).split(" ") ok = True for s in set: if not s in SYMBOLS: # TODO: informacja o tym (bugcheck) ok = False if not ok: check = True else: check = True if check and font.get("ToUnicode") == None: self.__write("Font " + str(id) + " should have ToUnicode CMap," + " but have not")
def __processFont(self, font): dict = font.dict result = u"" type = literal_name(dict.get("Subtype")) name = literal_name_none(dict.get("BaseFont")) if name != None: fullName = Font.removeSubset(name) descr = dict_value_none(dict.get("FontDescriptor")) family = None stretch = None weight = None file = None type1File = False file3 = False desName = None monospace = False serif = False symbolic = False script = False nonsymbolic = False italic = False allCap = False smallCap = False if descr != None: family = str_value_none(descr.get("FontFamily")) stretch = literal_name_none(descr.get("FontStretch")) weight = num_value_none(descr.get("FontWeight")) file = stream_value_none(descr.get("FontFile2")) type1File = descr.get("FontFile1") != None file3 = descr.get("FontFile3") != None desName = literal_name(descr.get("FontName")) if weight >= 700: strWeight = "bold" else: strWeight = "normal" flags = num_value(descr.get("Flags")) if flags == None: flags = 0 monospace = flags & 0x1 serif = flags & 0x2 symbolic = flags & 0x4 script = flags & 0x8 nonsymbolic = flags & 0x20 italic = flags & 0x40 allCap = flags & 0x10000 smallCap = flags & 0x20000 encoding = dict.get("Encoding") != None if type == "Type0": encoding = False enc = None if encoding: dEncoding = dict_value2(dict.get("Encoding")) if dEncoding != None: enc = dEncoding else: nEncoding = literal_name(dict.get("Encoding")) cmap = stream_value_none(dict.get("ToUnicode")) if name != None: result += "PostScript name: " + fullName + "\n" result += "Full name: " + name + "\n" if descr != None: result += "Descriptor: yes\n" elif type == "TrueType" or type == "Type1": result += "Descriptor: no\n" if desName != None: result += "Full name in descriptor : " + desName + "\n" if family != None: result += "Family: " + family + "\n" result += "Type: " + type + "\n" if stretch != None: result += "Stretch: " + stretch + "\n" if weight != None: result += "Weight: " + str(weight) + " (" + strWeight + ")\n" if descr != None: result += "Flags set: " useComma = False if monospace != 0: result += "monspace" useComma = True if serif != 0: if useComma: result += ", " result += "serif" useComma = True if symbolic != 0: if useComma: result += ", " result += "symbolic" useComma = True if italic != 0: if useComma: result += ", " result += "italic" useComma = True if nonsymbolic != 0: if useComma: result += ", " result += "nonsymbolic" useComma = True if script != 0: if useComma: result += ", " result += "script" useComma = True if allCap != 0: if useComma: result += ", " result += "allCap" useComma = True if smallCap != 0: if useComma: result += ", " result += "smallCap" result += "\n" if encoding: if enc == None: result += "Encoding: " + nEncoding + "\n" result2 = "" if file3: result2 += "Embedded file: non standard (FontFile3)\n" if type == "TrueType": if file != None: result2 += "Embedded file: yes\n" else: result2 += "Embedded file: no\n" if file != None: sio = StringIO(file.get_data()) fontFile = TTFontMod(sio) #print fontFile.getTableData("name") result2 += self.__processNamesTable(fontFile['name'].names) sio.close() elif type == "Type1": if type1File: result2 += "Embedded file: yes\n" else: result2 += "Embedded file: no\n" if cmap != None: result2 += "Mapping to unicode:\n" unicodeMap = FileUnicodeMap() sio = StringIO(cmap.get_data()) CMapParser(unicodeMap, sio).run() sio.close() i = 0 for (k, v) in unicodeMap.cid2unichr.iteritems(): i += 1 if unicode(v) == "\n": result2 += str(k) + ":\tLF\t" + hex(ord(unicode(v))) elif unicode(v) == "\r": result2 += str(k) + ":\tCR\t" + hex(ord(unicode(v))) elif unicode(v) == "\t": result2 += str(k) + ":\tTAB\t" + hex(ord(unicode(v))) else: code = "" j = 0 for c in unicode(v): j += 1 code += hex(ord(c)) + " " if j == 1 and i % 3 != 0: code += "\t" result2 += str(k) + ":\t" + unicode(v) + "\t" + code if i % 3 == 0: result2 += "\n" else: result2 += "\t\t" return (result, enc, result2)
class PhysList(wx.ListCtrl): def __init__(self, *args, **kwargs): wx.ListCtrl.__init__(self, *args, **kwargs) self.Bind(wx.EVT_LIST_ITEM_SELECTED, self.__onClick) self.__textCtrl = None # kontrolka w ktorej wyswietlamy tekst z informacjami # o pokazywanym obrazku lub foncie self.__root = None # obiekt PTree ze slownikami zasobow stron (patrz TagLib i # XMLLib) - nazwa jest pozostaloscia z czasow gdy ta kontrolka byla drzewem self.__frame = None # glowne okno aplikacji (MainWindow) self.__path = None # sciezka do wczytanego pliku PDF, potrzebna do wyciagniecia # obrazka z pliku self.__colorSpace = None # przestrzen kolorow ktora chcemy pokazac w osobnym # oknie dialogowym (patrz onURL, slownik przestrzeni koloru) self.__encoding = None # kodowanie znakow ktore chcemy pokazac w osobnym # oknie dialogowym (patrz onURL, slownik kodowania PDF) self.__urlMode = "Image" # jezeli ma wartosc Image to znaczy, ze w oknie # __textCtrl pokazujemy informacje o obrazku i link w nim prowadzi do # przestrzeni kolorow, wpp pokazujemy informacje o foncie i link # prowadzi do kodowania self.__nodes = [ ] # lista wezlow obiektu PTree z fontami i obrazkami, indeks # na tej liscie jest jednoczesnie informacja przechowywana w itemach # wxWidgets bedacych elementami tej kontrolki (patrz metoda show) # przygotowujemy sie do wczytania nowego pliku def restart(self): self.__root = None self.__path = None self.__colorSpace = None def setPath(self, path): self.__path = path def setFrame(self, frame): self.__frame = frame def setTextCtrl(self, textCtrl): self.__textCtrl = textCtrl # kliknieto na link # (poniewaz informacje o kodowaniu fontu i przestrzeni kolorow sa zlozone, sa # wyswietlane oknie dialogowym otwieranym po kliknieciu w odpowiedni link w # __textCtrl) def onURL(self, event): if self.__urlMode == "Image": # w __textCtrl pokazujemy informacje o obrazku, # a zatem link prowadzi do przestrzeni kolorow if self.__colorSpace != None: dia = ColourSpaceDialog(self, wx.ID_ANY, "Color space") dia.setColourSpace(self.__colorSpace) dia.ShowModal() # pokazujemy przestrzen kolorow dia.Destroy() else: # wpp pokazujemy informacje o foncie, a zatem link prowadzi do kodowania if self.__encoding != None: dia = ColourSpaceDialog(self, wx.ID_ANY, "Encoding") dia.setEncoding(self.__encoding) dia.ShowModal() # pokazujemy kodowanie dia.Destroy() #self.__textCtrl.EndAllStyles() #self.__textCtrl.EndUnderline() #self.__textCtrl.EndTextColour() #self.__textCtrl.EndURL() def setRoot(self, tree): self.__root = tree # pokazuje slownik zasobow strony o danym identyfikatorze page # jezeli seekedNodde != None to chcemy pokazac konkretny font (w zasadzie # (por. komentarze do MainWindow.switchTabs i Font.ptreeLink) moznaby od razu # wywolywac w MainWindow.switchTabs __showFont, a obecna implementacja to # pozostalosc gdy PhysList bylo drzewem i trzeba bylo je odpowiednio rozwijac; # powinno sie natomiast dodac jakies zaznaczanie odpowiedniego item wxWidgets # w kontrolce PhysList) def show(self, page, seekedNode=None): if self.__root == None: # wczytany plik jest plikiem XML i nie ma slownikow # zasobow stron return self.ClearAll() # czyscimy kontrolke self.__nodes = [] # j.w. id = 0 for c in self.__root.children: # dzieci korzenia PTree to strony #print c.data, page if c.data == page: # mamy strone ktorej szukamy for cc in c.children: # dzieci strony to fonty i obrazki (elementy # jej slownika zasobow) #item = wx.ListItem() #item.SetText(cc.label) #self.Append([cc.label]) self.InsertStringItem( id, cc.label) # dodajemy item wxWidgets do # listy #self.SetStringItem(id, 0, cc.label, id) self.SetItemData(id, id) # wkladamy do niego indeks na liscie # __node - dzieki temu mozemy sie z itema dostac do fontu # lub obrazka ktoremu od odpowiada id += 1 self.__nodes.append( cc) # dodajemy font lub obrazek do listy __nodes if seekedNode == cc: # tego parametru uzywamy, jezeli metode wywolano # z metody MainWindow.switchTabs, zeby pokazac font po # nacisnieciu na link w MainWindow.__textCtrl self.__showFont(cc) # pokazujemy font self.Refresh() # pokazuje dany font w __textCtrl # data - obiekt PTree reprezentujacy font def __showFont(self, data): #self.__textCtrl.EndAllStyles() self.__textCtrl.SetInsertionPoint( 0) # potrzebne, wpp caly tekst po kliknieciu self.__textCtrl.Clear() # na link robi sie niebieski (result, enc, result2) = self.__processFont(data.data) # zwraca tekst # z informacja o foncie, ktory ma byc wyswietlony, na podstawie # obiektu klasy Font (data.data) self.__textCtrl.WriteText(result) if enc != None: self.__textCtrl.BeginTextColour("#0000ff") self.__textCtrl.BeginUnderline() self.__textCtrl.BeginURL("0") self.__urlMode = "Font" # patrz onURL self.__encoding = enc # zapisuje na __encoding slownik kodowania fontu # ktory bedzie widoczny w metodzie onURL self.__textCtrl.WriteText("Encoding\n") self.__textCtrl.EndURL() self.__textCtrl.EndUnderline() self.__textCtrl.EndTextColour() self.__textCtrl.WriteText(result2) self.__textCtrl.ShowPosition(0) # kliknieto na jeden z itemow listy # pobiera na jego podstawie obiekt PTree odpowiadajacy fontowi lub obrazkowi z # listy __nodes i wyswietla w polu __textCtrl def __onClick(self, event): #print "ON CLICK", event.GetItem(), self.GetItemText(event.GetItem()) item = event.GetItem() #print item.GetData() data = self.__nodes[item.GetData()] #print ":" + str(item) + ":" + item.GetText() if item.GetText( )[0:4] == "Imag": # obrazek, odnosnie warunku patrz pole PTree.label #self.__textCtrl.MoveCaret(0, True) self.__textCtrl.SetInsertionPoint( 0) # potrzebne, wpp po kliknieciu na link #self.__textCtrl.EndAllStyles() #self.__textCtrl.EndURL() #self.__textCtrl.EndUnderline() #self.__textCtrl.EndTextColour() self.__textCtrl.Clear() # caly tekst robi sie niebieski (text, url, text2, img) = self.__processImage(data.data) #self.__textCtrl.AppendText(text) #self.__textCtrl.SetInsertionPoint(0) #self.__textCtrl.SetStyle(rt.RichTextRange(0.0, 10000.0), rt.TextAttrEx()) self.__textCtrl.WriteText(text) if url != None: self.__textCtrl.BeginTextColour("#0000ff") self.__textCtrl.BeginUnderline() self.__textCtrl.BeginURL("0") #print "begin" self.__urlMode = "Image" # patrz onURL, # self.__colorSpace ustawiane powyzej w metodzie __processImage self.__textCtrl.WriteText(url) #print url self.__textCtrl.EndURL() #print "end" self.__textCtrl.EndUnderline() self.__textCtrl.EndTextColour() #self.__textCtrl.BeginBold() self.__textCtrl.WriteText(text2) #self.__textCtrl.EndBold() #self.__textCtrl.EndAllStyles() self.__textCtrl.ShowPosition(0) self.__frame.showImage(img) elif item.GetText( )[0:4] == "Font": # font, przekazanie sterowania do metody # __showFont ktora zajmie sie fontem, odnosnie warunku patrz pole PTree.label #self.__textCtrl.SetInsertionPoint(0) #self.__textCtrl.Clear() self.__showFont(data) self.__frame.hideImage( ) # chowamy obrazek (bo moze byc po potrzednim # obiekcie) # wyciaga informacje ze slownika fontu (ktory z kolei wyciaga z obiektu klasy Font) # zwraca krotke (tekst do wyswietlenia przed linkiem do kodowania fontu, slownik kodowania fontu, # tekst do wyswietlenia po linku do kodowania fontu) jezeli kodowanie fontu jest w # postaci slownika lub (tekst do wyswietlenia przed nazwa kodowania fontu z nazwa # wlacznie, None, tekst do wyswietlenia po nazwie kodowania fontu) jezeli kodowanie fontu jest # w postaci nazwy def __processFont(self, font): dict = font.dict result = u"" type = literal_name(dict.get("Subtype")) name = literal_name_none(dict.get("BaseFont")) if name != None: fullName = Font.removeSubset(name) descr = dict_value_none(dict.get("FontDescriptor")) family = None stretch = None weight = None file = None type1File = False file3 = False desName = None monospace = False serif = False symbolic = False script = False nonsymbolic = False italic = False allCap = False smallCap = False if descr != None: family = str_value_none(descr.get("FontFamily")) stretch = literal_name_none(descr.get("FontStretch")) weight = num_value_none(descr.get("FontWeight")) file = stream_value_none(descr.get("FontFile2")) type1File = descr.get("FontFile1") != None file3 = descr.get("FontFile3") != None desName = literal_name(descr.get("FontName")) if weight >= 700: strWeight = "bold" else: strWeight = "normal" flags = num_value(descr.get("Flags")) if flags == None: flags = 0 monospace = flags & 0x1 serif = flags & 0x2 symbolic = flags & 0x4 script = flags & 0x8 nonsymbolic = flags & 0x20 italic = flags & 0x40 allCap = flags & 0x10000 smallCap = flags & 0x20000 encoding = dict.get("Encoding") != None if type == "Type0": encoding = False enc = None if encoding: dEncoding = dict_value2(dict.get("Encoding")) if dEncoding != None: enc = dEncoding else: nEncoding = literal_name(dict.get("Encoding")) cmap = stream_value_none(dict.get("ToUnicode")) if name != None: result += "PostScript name: " + fullName + "\n" result += "Full name: " + name + "\n" if descr != None: result += "Descriptor: yes\n" elif type == "TrueType" or type == "Type1": result += "Descriptor: no\n" if desName != None: result += "Full name in descriptor : " + desName + "\n" if family != None: result += "Family: " + family + "\n" result += "Type: " + type + "\n" if stretch != None: result += "Stretch: " + stretch + "\n" if weight != None: result += "Weight: " + str(weight) + " (" + strWeight + ")\n" if descr != None: result += "Flags set: " useComma = False if monospace != 0: result += "monspace" useComma = True if serif != 0: if useComma: result += ", " result += "serif" useComma = True if symbolic != 0: if useComma: result += ", " result += "symbolic" useComma = True if italic != 0: if useComma: result += ", " result += "italic" useComma = True if nonsymbolic != 0: if useComma: result += ", " result += "nonsymbolic" useComma = True if script != 0: if useComma: result += ", " result += "script" useComma = True if allCap != 0: if useComma: result += ", " result += "allCap" useComma = True if smallCap != 0: if useComma: result += ", " result += "smallCap" result += "\n" if encoding: if enc == None: result += "Encoding: " + nEncoding + "\n" result2 = "" if file3: result2 += "Embedded file: non standard (FontFile3)\n" if type == "TrueType": if file != None: result2 += "Embedded file: yes\n" else: result2 += "Embedded file: no\n" if file != None: sio = StringIO(file.get_data()) fontFile = TTFontMod(sio) #print fontFile.getTableData("name") result2 += self.__processNamesTable(fontFile['name'].names) sio.close() elif type == "Type1": if type1File: result2 += "Embedded file: yes\n" else: result2 += "Embedded file: no\n" if cmap != None: result2 += "Mapping to unicode:\n" unicodeMap = FileUnicodeMap() sio = StringIO(cmap.get_data()) CMapParser(unicodeMap, sio).run() sio.close() i = 0 for (k, v) in unicodeMap.cid2unichr.iteritems(): i += 1 if unicode(v) == "\n": result2 += str(k) + ":\tLF\t" + hex(ord(unicode(v))) elif unicode(v) == "\r": result2 += str(k) + ":\tCR\t" + hex(ord(unicode(v))) elif unicode(v) == "\t": result2 += str(k) + ":\tTAB\t" + hex(ord(unicode(v))) else: code = "" j = 0 for c in unicode(v): j += 1 code += hex(ord(c)) + " " if j == 1 and i % 3 != 0: code += "\t" result2 += str(k) + ":\t" + unicode(v) + "\t" + code if i % 3 == 0: result2 += "\n" else: result2 += "\t\t" return (result, enc, result2) # wyciaga informacje z tabeli nazw fontu TrueType def __processNamesTable(self, names): copyright = None license = None family = None style = None completeName = None psName = None tm = None licenseURL = None winFamily = None winStyle = None macFamily = None res = u"" for n in names: #print n.platformID, n.platEncID, n.langID if (n.platformID == 0 or (n.platformID == 1 and n.platEncID == 0 and n.langID == 0x0) or (n.platformID == 2 and n.platEncID == 1 and n.langID == 0x0409)): if (n.platformID == 1): #sys.stderr.write("[" + n.string + "]") #sys.stderr.write("[" + n.string.decode("latin-1") + "]") data = n.string.decode("latin-1") else: data = uniToString(n.string) if len(n.string) == 0: continue if n.nameID == 0: copyright = data elif n.nameID == 1: family = data elif n.nameID == 13: license = data elif n.nameID == 2: style = data elif n.nameID == 4: completeName = data elif n.nameID == 6: psName = data elif n.nameID == 7: tm = data elif n.nameID == 14: licenseURL = data elif n.nameID == 16: winFamily = data elif n.nameID == 17: winStyle = data elif n.nameID == 18: macFamily = data res += u"Font embedded information:\n" if copyright != None: res += u"\tCopyright notice: " + copyright + u"\n" if license != None: res += "\tLicense:\n" + license + "\n" if licenseURL != None: res += "\tLicense URL: " + licenseURL + "\n" if tm != None: res += "\tTrademark: " + tm + "\n" if family != None: res += "\tFamily name: " + family + "\n" if style != None: res += "\tStyle: " + style + "\n" if completeName != None: res += "\tComplete name: " + completeName + "\n" if psName != None: res += "\tPostScript name: " + psName + "\n" if winFamily != None: res += "\tWindows family name: " + winFamily + "\n" if winStyle != None: res += "\tWindows style: " + winStyle + "\n" if macFamily != None: res += "\tMac family name: " + macFamily + "\n" return res # wyciaga informacje o obrazku ze slownika obrazka # znaczenie parametrow - patrz komentarz do pola PTree.data # zwraca krotke (tekst do wyswietlenia przed linkiem do przestrzeni kolorow, # tekst linka do przestrzeni kolorow, tekst do wyswietlenia po linku do przestrzeni # kolorow, obrazek do narysowania przez ImagePanel (obiekt klasy wx.Image)) - jezeli # przestrzen kolorow jest skomplikowana i trzeba ja przedstawic w osobnym oknie - # - lub krotke (tekst do wyswietlenia przed przestrzenia kolorow i przestrzen kolorow, # None, tekst do wyswietlenia po przestrzeni kolorow) - jezeli przestrzen kolorow # mozna przedstawic w postaci prostego napisu def __processImage(self, (img, page, num, genno)): result = "" length = num_value(img.get("Length")) name = literal_name_none(img.get("Name")) filters = None filter = None if list_value2(img.get("Filter")) != None: filters = [] for f in list_value(img.get("Filter")): filters.append(literal_name(f)) else: filter = literal_name_none(img.get("Filter")) file = img.get("F") width = num_value(img.get("Width")) height = num_value(img.get("Height")) url = None if list_value2(img.get("ColorSpace")) != None: colourSpace = literal_name(list_value(img.get("ColorSpace"))[0]) if colourSpace in ["ICCBased", "Separation", "DeviceN", "Indexed"]: url = colourSpace + "\n" self.__colorSpace = img.get( "ColorSpace") # zapamietujemy przestrzen # kolorow zeby byla widoczna w metodzie onURL elif colourSpace in ["CalGray", "CalRGB", "Lab"]: colourSpace += ", " + str( dict_value(list_value(img.get("ColorSpace"))[1])) else: colourSpace = literal_name_none(img.get("ColorSpace")) bpp = num_value_none(img.get("BitsPerComponent")) mask = num_value_none(img.get("ImageMask")) intent = literal_name_none(img.get("Intent")) if mask != 0 and mask != None: result += "Mask\n" dict = None mode = None isMask = mask != 0 and mask != None #print page, num, genno, isMask if file == None: # TODO: D czy pdfimages poradzi sobie z wielokrotnymi filtrami (imag, _, _) = getWxImage(self.__path, page, num, genno, isMask, self.__frame) # wyciagamy obrazek z pliku (patrz imagextract.py i PDFAUtilitiesCpp) else: imag = None exif = "" if filter == "DCTDecode" and file == None: # JPEG parser = ImageFile.Parser() parser.feed(img.rawdata) image = parser.close() dict = image.info mode = image.mode sio = StringIO(img.rawdata) exif = extractExif(sio) # wyciagamy metadane EXIF z obrazka JPEG sio.close() hasMetadata = img.get("Metadata") != None if name != None: result += "Name: " + name + "\n" result += "Length: " + str(length) + "\n" if filters != None and len(filters) > 0: result += "Filters: " result += filters[0] for f in filters[1:]: result += ", " + filters[1] result += "\n" if filter != None: result += "Filter: " + filter + "\n" else: result += "No filter used\n" result += "Dimensions: " + str(width) + "x" + str(height) + "\n" if url == None and colourSpace != None: result += "Colour space: " + str(colourSpace) + "\n" result2 = "" if bpp != None: result2 += "BPP: " + str(bpp) + "\n" if intent != None: result2 += "Intent: " + intent + "\n" if hasMetadata: result2 += "Metadata: yes\n" else: result2 += "Metadata: no\n" if dict != None or mode != None or exif != "": result2 += "File embedded information:\n" if dict != None: dict = self.__formatJfif(dict) for (k, v) in dict.iteritems(): result2 += "\t" + str(k) + ": " + str(v) + "\n" if exif != "": result2 += exif if mode != None: result2 += "\t" + "Mode: " + str(mode) + "\n" if imag == None: if file != None: result2 += "Image in external file\n" else: result2 += "Image not from this page!\n" # moze sie zdarzyc, ze # slowniki zasobow sa dzielone miedzy wiele stron; # wtedy metoda getWxImage zwroci obrazek tylko wtedy, jezeli # aktualnie pokazujemy slownik zasobow dla strony na ktorej # jest ten obrazek; # dla innych stron, mimo ze maja ten sam slownik zasobow, # zostanie pokazany ten komunikat return (result, url, result2, imag)
def setColourSpace(self, cs): #self.__control.SetInsertionPoint(0) #self.__control.Clear() #self.__object = cs if list_value2(cs) != None: colourSpace = literal_name(list_value(cs)[0]) self.__control.WriteText("Type: " + colourSpace + "\n") if colourSpace == "ICCBased": param = stream_value(list_value(cs)[1]) tmpDict = {} if param.get("N") != None: tmpDict.setdefault("N", param.get("N")) if param.get("Range") != None: tmpDict.setdefault("Range", param.get("Range")) self.__control.WriteText(str(tmpDict) + "\n") if list_value2(param.get("Alternate")) == None: if param.get("Alternate") != None: self.__control.WriteText( "Alternate color space: " + literal_name(param.get("Alternate")) + "\n") if param.get("Alternate") != None: self.__control.BeginURL("0") self.__control.BeginTextColour("#0000ff") self.__control.BeginUnderline() self.__control.WriteText("Alternate color space\n") self.__control.EndURL() self.__control.EndUnderline() self.__control.EndTextColour() self.__childObject = param.get("Alternate") self.__control.WriteText("ICC profile: " + hexdump(param.get_data()) + "\n") elif colourSpace in ["CalGray", "CalRGB", "Lab"]: self.__control.WriteText( str(dict_value(list_value(cs)[1])) + "\n") elif colourSpace == "Indexed": self.__control.WriteText(colourSpace + "\n") self.__control.WriteText("Hival: " + str(list_value(cs)[2]) + "\n") self.__control.WriteText("Lookup: " + str(list_value(cs)[3]) + "\n") if list_value2(list_value(cs)[3]) == None: self.__control.WriteText("Base color space: " + literal_name(list_value(cs)[3]) + "n") else: self.__control.BeginURL("0") self.__control.BeginTextColour("#0000ff") self.__control.BeginUnderline() self.__control.Writetext("Base color space\n") self.__control.EndURL() self.__control.EndUnderline() self.__control.EndTextColour() self.__childObject = list_value(cs)[3] elif colourSpace in ["Separation", "DeviceN"]: # TODO: E implementacja przestrzeni kolorantow w atrybutach DeviceN self.__control.WriteText(colourSpace + "\n") self.__control.WriteText("Names: " + str(list_value(cs)[1]) + "\n") self.__control.WriteText("Tint transform : " + str(list_value(cs)[3]) + "\n") if list_value2(list_value(cs)[2]) == None: self.__control.WriteText("Alternate color space: " + literal_name(list_value(cs)[2]) + "\n") else: self.__control.BeginURL("0") self.__control.BeginTextColour("#0000ff") self.__control.BeginUnderline() self.__control.Writetext("Alternate color space\n") self.__control.EndURL() self.__control.EndUnderline() self.__control.EndTextColour() self.__childObject = list_value(cs)[2] self.__control.ShowPosition(0)