/** * Processes a dictionary. * In case of font dictionaries, the dictionary is processed. */ public void UnembedTTF(PdfDictionary dict) { // we ignore all dictionaries that aren't font dictionaries if (!dict.IsFont()) return; // we only remove TTF fonts if (dict.GetAsDict(PdfName.FONTFILE2) != null) { return; } // check if a subset was used (in which case we remove the prefix) PdfName baseFont = dict.GetAsName(PdfName.BASEFONT); if (baseFont.GetBytes()[7] == '+') { baseFont = new PdfName(baseFont.ToString().Substring(8)); dict.Put(PdfName.BASEFONT, baseFont); } // we check if there's a font descriptor PdfDictionary fontDescriptor = dict.GetAsDict(PdfName.FONTDESCRIPTOR); if (fontDescriptor == null) return; // is there is, we replace the fontname and remove the font file fontDescriptor.Put(PdfName.FONTNAME, baseFont); fontDescriptor.Remove(PdfName.FONTFILE2); }
private ImageRenderInfo(Matrix ctm, InlineImageInfo inlineImageInfo, PdfDictionary colorSpaceDictionary) { this.ctm = ctm; this.refi = null; this.inlineImageInfo = inlineImageInfo; this.colorSpaceDictionary = colorSpaceDictionary; }
/** * Shows the detail of a dictionary. * @param dic the dictionary of which you want the detail * @param depth the depth of the current dictionary (for nested dictionaries) * @return a String representation of the dictionary */ public static String GetDictionaryDetail(PdfDictionary dic, int depth){ StringBuilder builder = new StringBuilder(); builder.Append('('); IList<PdfName> subDictionaries = new List<PdfName>(); foreach (PdfName key in dic.Keys) { PdfObject val = dic.GetDirectObject(key); if (val.IsDictionary()) subDictionaries.Add(key); builder.Append(key); builder.Append('='); builder.Append(val); builder.Append(", "); } builder.Length = builder.Length-2; builder.Append(')'); foreach (PdfName pdfSubDictionaryName in subDictionaries) { builder.Append('\n'); for (int i = 0; i < depth+1; i++){ builder.Append('\t'); } builder.Append("Subdictionary "); builder.Append(pdfSubDictionaryName); builder.Append(" = "); builder.Append(GetDictionaryDetail(dic.GetAsDict(pdfSubDictionaryName), depth+1)); } return builder.ToString(); }
public static Hashtable ReadTree(PdfDictionary dic) { Hashtable items = new Hashtable(); if (dic != null) IterateItems(dic, items); return items; }
private ImageRenderInfo(Matrix ctm, PdfIndirectReference refi, PdfDictionary colorSpaceDictionary) { this.ctm = ctm; this.refi = refi; this.inlineImageInfo = null; this.colorSpaceDictionary = colorSpaceDictionary; }
// --------------------------------------------------------------------------- public byte[] CreatePdf() { using (MemoryStream ms = new MemoryStream()) { // step 1 using (Document document = new Document(new Rectangle(850, 600))) { // step 2 PdfWriter writer = PdfWriter.GetInstance(document, ms); // step 3 document.Open(); // step 4 PdfContentByte canvas = writer.DirectContent; // add the clipped image Image img = Image.GetInstance( Path.Combine(Utility.ResourceImage, RESOURCE) ); float w = img.ScaledWidth; float h = img.ScaledHeight; canvas.Ellipse(1, 1, 848, 598); canvas.Clip(); canvas.NewPath(); canvas.AddImage(img, w, 0, 0, h, 0, -600); // Create a transparent PdfTemplate PdfTemplate t2 = writer.DirectContent.CreateTemplate(850, 600); PdfTransparencyGroup transGroup = new PdfTransparencyGroup(); transGroup.Put( PdfName.CS, PdfName.DEVICEGRAY); transGroup.Isolated = true; transGroup.Knockout = false; t2.Group = transGroup; // Add transparent ellipses to the template int gradationStep = 30; float[] gradationRatioList = new float[gradationStep]; for(int i = 0; i < gradationStep; i++) { /* * gotta love .NET, guess they forgot to copy java.lang.Math.toRadians */ double radians = (Math.PI / 180) * 90.0f / gradationStep * (i + 1); gradationRatioList[i] = 1 - (float) Math.Sin(radians); } for(int i = 1; i < gradationStep + 1; i++) { t2.SetLineWidth(5 * (gradationStep + 1 - i)); t2.SetGrayStroke(gradationRatioList[gradationStep - i]); t2.Ellipse(0, 0, 850, 600); t2.Stroke(); } // Create an image mask for the direct content PdfDictionary maskDict = new PdfDictionary(); maskDict.Put(PdfName.TYPE, PdfName.MASK); maskDict.Put(PdfName.S, new PdfName("Luminosity")); maskDict.Put(new PdfName("G"), t2.IndirectReference); PdfGState gState = new PdfGState(); gState.Put(PdfName.SMASK, maskDict ); canvas.SetGState(gState); canvas.AddTemplate(t2, 0, 0); } return ms.ToArray(); } }
/** * Maps the user tags to the standard tags. The mapping will allow a standard application to make some sense of the tagged * document whatever the user tags may be. * @param used the user tag * @param standard the standard tag */ public void MapRole(PdfName used, PdfName standard) { PdfDictionary rm = (PdfDictionary)Get(PdfName.ROLEMAP); if (rm == null) { rm = new PdfDictionary(); Put(PdfName.ROLEMAP, rm); } rm.Put(used, standard); }
// --------------------------------------------------------------------------- public void Write(Stream stream) { // step 1 using (Document document = new Document()) { // step 2 PdfWriter writer = PdfWriter.GetInstance(document, stream); // step 3 document.Open(); // step 4 Rectangle rect = new Rectangle(100, 400, 500, 800); rect.Border = Rectangle.BOX; rect.BorderWidth = 0.5f; rect.BorderColor = new BaseColor(0xFF, 0x00, 0x00); document.Add(rect); PdfIndirectObject streamObject = null; using (FileStream fs = new FileStream(RESOURCE, FileMode.Open, FileAccess.Read)) { PdfStream stream3D = new PdfStream(fs, writer); stream3D.Put(PdfName.TYPE, new PdfName("3D")); stream3D.Put(PdfName.SUBTYPE, new PdfName("U3D")); stream3D.FlateCompress(); streamObject = writer.AddToBody(stream3D); stream3D.WriteLength(); } PdfDictionary dict3D = new PdfDictionary(); dict3D.Put(PdfName.TYPE, new PdfName("3DView")); dict3D.Put(new PdfName("XN"), new PdfString("Default")); dict3D.Put(new PdfName("IN"), new PdfString("Unnamed")); dict3D.Put(new PdfName("MS"), PdfName.M); dict3D.Put( new PdfName("C2W"), new PdfArray( new float[] { 1, 0, 0, 0, 0, -1, 0, 1, 0, 3, -235, 28 } ) ); dict3D.Put(PdfName.CO, new PdfNumber(235)); PdfIndirectObject dictObject = writer.AddToBody(dict3D); PdfAnnotation annot = new PdfAnnotation(writer, rect); annot.Put(PdfName.CONTENTS, new PdfString("3D Model")); annot.Put(PdfName.SUBTYPE, new PdfName("3D")); annot.Put(PdfName.TYPE, PdfName.ANNOT); annot.Put(new PdfName("3DD"), streamObject.IndirectReference); annot.Put(new PdfName("3DV"), dictObject.IndirectReference); PdfAppearance ap = writer.DirectContent.CreateAppearance( rect.Width, rect.Height ); annot.SetAppearance(PdfAnnotation.APPEARANCE_NORMAL, ap); annot.SetPage(); writer.AddAnnotation(annot); } }
// methods internal void Add(PdfName key, PdfDictionary resource) { if (resource.Size == 0) return; PdfDictionary dic = GetAsDict(key); if (dic == null) Put(key, resource); else dic.Merge(resource); }
/** * Creates and XMP writer that adds info about the PDF/A conformance level. * @param os * @param info * @param conformanceLevel * @throws IOException */ public PdfAXmpWriter(Stream os, PdfDictionary info, PdfAConformanceLevel conformanceLevel) : base(os, info) { try { AddRdfDescription(conformanceLevel); } catch (XmpException xmpExc) { throw new IOException(xmpExc.Message); } }
internal void AddPage(PdfDictionary page) { if ((pages.Count % leafSize) == 0) parents.Add(writer.PdfIndirectReference); PdfIndirectReference parent = parents[parents.Count - 1]; page.Put(PdfName.PARENT, parent); PdfIndirectReference current = writer.CurrentPage; writer.AddToBody(page, current); pages.Add(current); }
internal PdfMediaClipData(String file, PdfFileSpecification fs, String mimeType) { Put(PdfName.TYPE,new PdfName("MediaClip")); Put(PdfName.S, new PdfName("MCD")); Put(PdfName.N, new PdfString("Media clip for "+file)); Put(new PdfName("CT"), new PdfString(mimeType)); PdfDictionary dic = new PdfDictionary(); dic.Put(new PdfName("TF"), new PdfString("TEMPACCESS")); Put(new PdfName("P"), dic); Put(PdfName.D, fs.Reference); }
// methods internal void Add(PdfName key, PdfDictionary resource) { if (resource.Size == 0) return; PdfDictionary dic = (PdfDictionary)PdfReader.GetPdfObject(Get(key)); if (dic == null) Put(key, resource); else dic.Merge(resource); }
/** * Creates an instance of a CMapAwareFont based on an indirect reference to a font. * @param refFont the indirect reference to a font */ public CMapAwareDocumentFont(PRIndirectReference refFont) : base(refFont){ fontDic = (PdfDictionary)PdfReader.GetPdfObjectRelease(refFont); ProcessToUnicode(); //if (toUnicodeCmap == null) ProcessUni2Byte(); spaceWidth = base.GetWidth(' '); if (spaceWidth == 0){ spaceWidth = ComputeAverageWidth(); } }
private void addAsAttachment(IDataExporter exporter, byte[] data) { if (string.IsNullOrEmpty(exporter.FileName)) throw new InvalidOperationException("Please fill the exporter.FileName."); if (string.IsNullOrEmpty(exporter.Description)) exporter.Description = "Exported data"; var pdfDictionary = new PdfDictionary(); pdfDictionary.Put(PdfName.MODDATE, new PdfDate(DateTime.Now)); var fs = PdfFileSpecification.FileEmbedded(_sharedData.PdfWriter, null, exporter.FileName, data, true, null, pdfDictionary); _sharedData.PdfWriter.AddFileAttachment(exporter.Description, fs); }
protected internal void SetReader(PdfReader reader){ this.reader = reader; PdfObject obj = reader.Catalog.Get(PdfName.STRUCTTREEROOT); obj = GetDirectObject(obj); if ((obj == null) || (!obj.IsDictionary())) throw new BadPdfFormatException(MessageLocalization.GetComposedMessage("no.structtreeroot.found")); structTreeRoot = (PdfDictionary)obj; obj = PdfStructTreeController.GetDirectObject(structTreeRoot.Get(PdfName.PARENTTREE)); if (!obj.IsDictionary()) throw new BadPdfFormatException(MessageLocalization.GetComposedMessage("the.document.does.not.contain.parenttree")); parentTree = (PdfDictionary)obj; sourceRoleMap = null; sourceClassMap = null; }
internal PdfStructureElement(PdfDictionary parent, PdfName structureType) { if (parent is PdfStructureElement) { top = ((PdfStructureElement) parent).top; Init(parent, structureType); this.parent = (PdfStructureElement) parent; Put(PdfName.P, ((PdfStructureElement) parent).reference); Put(PdfName.TYPE, PdfName.STRUCTELEM); } else if (parent is PdfStructureTreeRoot) { top = (PdfStructureTreeRoot) parent; Init(parent, structureType); Put(PdfName.P, ((PdfStructureTreeRoot) parent).Reference); Put(PdfName.TYPE, PdfName.STRUCTELEM); } else {} }
public PRStream(PRStream stream, PdfDictionary newDic) { reader = stream.reader; offset = stream.offset; length = stream.Length; compressed = stream.compressed; compressionLevel = stream.compressionLevel; streamBytes = stream.streamBytes; bytes = stream.bytes; objNum = stream.objNum; objGen = stream.objGen; if (newDic != null) Merge(newDic); else Merge(stream); }
/// <summary> /// Sets PDF/A Conformance ColorProfile. /// </summary> public void SetColorProfile() { if (PageSetup.ConformanceLevel == PdfXConformance.PDFXNONE) return; var pdfDictionary = new PdfDictionary(PdfName.OUTPUTINTENT); pdfDictionary.Put(PdfName.OUTPUTCONDITIONIDENTIFIER, new PdfString("sRGB IEC61966-2.1")); pdfDictionary.Put(PdfName.INFO, new PdfString("sRGB IEC61966-2.1")); pdfDictionary.Put(PdfName.S, PdfName.GTS_PDFA1); var profileStream = StreamHelper.GetResourceByName("PdfRpt.Core.Helper.srgb.profile"); var pdfICCBased = new PdfICCBased(ICC_Profile.GetInstance(profileStream)); pdfICCBased.Remove(PdfName.ALTERNATE); pdfDictionary.Put(PdfName.DESTOUTPUTPROFILE, PdfWriter.AddToBody(pdfICCBased).IndirectReference); PdfWriter.ExtraCatalog.Put(PdfName.OUTPUTINTENTS, new PdfArray(pdfDictionary)); }
// --------------------------------------------------------------------------- /** * Extracts the font names from page or XObject resources. * @param set the HashSet with the font names * @param resources the resources dictionary */ public void ProcessResource(HashSet<String> set, PdfDictionary resource) { if (resource == null) return; PdfDictionary xobjects = resource.GetAsDict(PdfName.XOBJECT); if (xobjects != null) { foreach (PdfName key in xobjects.Keys) { ProcessResource(set, xobjects.GetAsDict(key)); } } PdfDictionary fonts = resource.GetAsDict(PdfName.FONT); if (fonts == null) return; PdfDictionary font; foreach (PdfName key in fonts.Keys) { font = fonts.GetAsDict(key); String name = font.GetAsName(PdfName.BASEFONT).ToString(); if (name.Length > 8 && name.Substring(7, 1) == "+") { name = String.Format( "{0} subset ({1})", name.Substring(8), name.Substring(1, 7) ); } else { name = name.Substring(1); PdfDictionary desc = font.GetAsDict(PdfName.FONTDESCRIPTOR); if (desc == null) { name += " nofontdescriptor"; } else if (desc.Get(PdfName.FONTFILE) != null) { name += " (Type 1) embedded"; } else if (desc.Get(PdfName.FONTFILE2) != null) { name += " (TrueType) embedded"; } else if (desc.Get(PdfName.FONTFILE3) != null) { name += " (" + font.GetAsName(PdfName.SUBTYPE).ToString().Substring(1) + ") embedded"; } } set.Add(name); } }
internal void SetOriginalResources(PdfDictionary resources, int[] newNamePtr) { if (newNamePtr != null) namePtr = newNamePtr; forbiddenNames = new Dictionary<PdfName,object>(); usedNames = new Dictionary<PdfName,PdfName>(); if (resources == null) return; originalResources = new PdfDictionary(); originalResources.Merge(resources); foreach (PdfName key in resources.Keys) { PdfObject sub = PdfReader.GetPdfObject(resources.Get(key)); if (sub != null && sub.IsDictionary()) { PdfDictionary dic = (PdfDictionary)sub; foreach (PdfName name in dic.Keys) { forbiddenNames[name] = null; } PdfDictionary dic2 = new PdfDictionary(); dic2.Merge(dic); originalResources.Put(key, dic2); } } }
private ReturnType CopyPageMarks(PdfDictionary parentTree, PdfNumber arrayNumber, int newArrayNumber) { PdfArray pages = (PdfArray)GetDirectObject(parentTree.Get(PdfName.NUMS)); if (pages == null) { PdfArray kids = (PdfArray)GetDirectObject(parentTree.Get(PdfName.KIDS)); if (kids == null) return ReturnType.NOTFOUND; int cur = kids.Size/2; int begin = 0; while (true) { PdfDictionary kidTree = (PdfDictionary)GetDirectObject(kids[cur + begin]); switch (CopyPageMarks(kidTree,arrayNumber,newArrayNumber)) { case ReturnType.FOUND: return ReturnType.FOUND; case ReturnType.ABOVE: begin += cur; cur /= 2; if (cur == 0) cur = 1; if (cur + begin == kids.Size) return ReturnType.ABOVE; break; case ReturnType.BELOW: if (cur + begin == 0) return ReturnType.BELOW; if (cur == 0) return ReturnType.NOTFOUND; cur /= 2; break; default: return ReturnType.NOTFOUND; } } } else { if (pages.Size == 0) return ReturnType.NOTFOUND; return FindAndCopyMarks(pages, arrayNumber.IntValue, newArrayNumber); } }
public virtual PdfObject GetPdfObject(PdfWriter writer) { PdfArray array = new PdfArray(PdfName.LAB); PdfDictionary dictionary = new PdfDictionary(); if (whitePoint == null || whitePoint.Length != 3 || whitePoint[0] < 0.000001f || whitePoint[2] < 0.000001f || whitePoint[1] < 0.999999f || whitePoint[1] > 1.000001f) throw new Exception(MessageLocalization.GetComposedMessage("lab.cs.white.point")); dictionary.Put(PdfName.WHITEPOINT, new PdfArray(whitePoint)); if (blackPoint != null) { if (blackPoint.Length != 3 || blackPoint[0] < -0.000001f || blackPoint[1] < -0.000001f || blackPoint[2] < -0.000001f) throw new Exception(MessageLocalization.GetComposedMessage("lab.cs.black.point")); dictionary.Put(PdfName.BLACKPOINT, new PdfArray(blackPoint)); } if (range != null) { if (range.Length != 4 || range[0] > range[1] || range[2] > range[3]) throw new Exception(MessageLocalization.GetComposedMessage("lab.cs.range")); dictionary.Put(PdfName.RANGE, new PdfArray(range)); } array.Add(dictionary); return array; }
void Manipulate(ip.PdfDictionary element) { if (element == null) { return; } if (ip.PdfName.FIGURE.Equals(element.Get(ip.PdfName.S))) { element.Put(ip.PdfName.ALT, new ip.PdfString("Image")); } var kids = element.GetAsArray(ip.PdfName.K); if (kids == null) { return; } for (var i = 0; i < kids.Size; i++) { Manipulate(kids.GetAsDict(i)); } }
private void DoType1TT() { CMapToUnicode toUnicode = null; PdfObject enc = PdfReader.GetPdfObject(font.Get(PdfName.ENCODING)); if (enc == null) { FillEncoding(null); toUnicode = ProcessToUnicode(); if (toUnicode != null) { IDictionary <int, int> rm = toUnicode.CreateReverseMapping(); foreach (KeyValuePair <int, int> kv in rm) { uni2byte[kv.Key] = kv.Value; } } } else { if (enc.IsName()) { FillEncoding((PdfName)enc); } else if (enc.IsDictionary()) { PdfDictionary encDic = (PdfDictionary)enc; enc = PdfReader.GetPdfObject(encDic.Get(PdfName.BASEENCODING)); if (enc == null) { FillEncoding(null); } else { FillEncoding((PdfName)enc); } PdfArray diffs = encDic.GetAsArray(PdfName.DIFFERENCES); if (diffs != null) { diffmap = new IntHashtable(); int currentNumber = 0; for (int k = 0; k < diffs.Size; ++k) { PdfObject obj = diffs[k]; if (obj.IsNumber()) { currentNumber = ((PdfNumber)obj).IntValue; } else { int[] c = GlyphList.NameToUnicode(PdfName.DecodeName(((PdfName)obj).ToString())); if (c != null && c.Length > 0) { uni2byte[c[0]] = currentNumber; diffmap[c[0]] = currentNumber; } else { if (toUnicode == null) { toUnicode = ProcessToUnicode(); if (toUnicode == null) { toUnicode = new CMapToUnicode(); } } string unicode = toUnicode.Lookup(new byte[] { (byte)currentNumber }, 0, 1); if ((unicode != null) && (unicode.Length == 1)) { this.uni2byte[unicode[0]] = currentNumber; this.diffmap[unicode[0]] = currentNumber; } } ++currentNumber; } } } } } PdfArray newWidths = font.GetAsArray(PdfName.WIDTHS); PdfNumber first = font.GetAsNumber(PdfName.FIRSTCHAR); PdfNumber last = font.GetAsNumber(PdfName.LASTCHAR); if (BuiltinFonts14.ContainsKey(fontName)) { BaseFont bf; bf = BaseFont.CreateFont(fontName, WINANSI, false); int[] e = uni2byte.ToOrderedKeys(); for (int k = 0; k < e.Length; ++k) { int n = uni2byte[e[k]]; widths[n] = bf.GetRawWidth(n, GlyphList.UnicodeToName(e[k])); } if (diffmap != null) //widths for differences must override existing ones { e = diffmap.ToOrderedKeys(); for (int k = 0; k < e.Length; ++k) { int n = diffmap[e[k]]; widths[n] = bf.GetRawWidth(n, GlyphList.UnicodeToName(e[k])); } diffmap = null; } Ascender = bf.GetFontDescriptor(ASCENT, 1000); CapHeight = bf.GetFontDescriptor(CAPHEIGHT, 1000); Descender = bf.GetFontDescriptor(DESCENT, 1000); ItalicAngle = bf.GetFontDescriptor(ITALICANGLE, 1000); fontWeight = bf.GetFontDescriptor(FONT_WEIGHT, 1000); llx = bf.GetFontDescriptor(BBOXLLX, 1000); lly = bf.GetFontDescriptor(BBOXLLY, 1000); urx = bf.GetFontDescriptor(BBOXURX, 1000); ury = bf.GetFontDescriptor(BBOXURY, 1000); } if (first != null && last != null && newWidths != null) { int f = first.IntValue; int nSize = f + newWidths.Size; if (widths.Length < nSize) { int[] tmp = new int[nSize]; System.Array.Copy(widths, 0, tmp, 0, f); widths = tmp; } for (int k = 0; k < newWidths.Size; ++k) { widths[f + k] = newWidths.GetAsNumber(k).IntValue; } } FillFontDesc(font.GetAsDict(PdfName.FONTDESCRIPTOR)); }
public byte[] Decode(byte[] b, PdfName filterName, PdfObject decodeParams, PdfDictionary streamDictionary) { return(b); }
virtual public bool ReadKey(PdfDictionary enc, byte[] password) { if (password == null) { password = new byte[0]; } byte[] oValue = DocWriter.GetISOBytes(enc.Get(PdfName.O).ToString()); byte[] uValue = DocWriter.GetISOBytes(enc.Get(PdfName.U).ToString()); byte[] oeValue = DocWriter.GetISOBytes(enc.Get(PdfName.OE).ToString()); byte[] ueValue = DocWriter.GetISOBytes(enc.Get(PdfName.UE).ToString()); byte[] perms = DocWriter.GetISOBytes(enc.Get(PdfName.PERMS).ToString()); PdfNumber pValue = (PdfNumber)enc.Get(PdfName.P); this.oeKey = oeValue; this.ueKey = ueValue; this.perms = perms; this.ownerKey = oValue; this.userKey = uValue; this.permissions = pValue.LongValue; bool isUserPass = false; IDigest md = DigestUtilities.GetDigest("SHA-256"); md.BlockUpdate(password, 0, Math.Min(password.Length, 127)); md.BlockUpdate(oValue, VALIDATION_SALT_OFFSET, SALT_LENGHT); md.BlockUpdate(uValue, 0, OU_LENGHT); byte[] hash = DigestUtilities.DoFinal(md); bool isOwnerPass = CompareArray(hash, oValue, 32); AESCipherCBCnoPad ac; if (isOwnerPass) { md.BlockUpdate(password, 0, Math.Min(password.Length, 127)); md.BlockUpdate(oValue, KEY_SALT_OFFSET, SALT_LENGHT); md.BlockUpdate(uValue, 0, OU_LENGHT); md.DoFinal(hash, 0); ac = new AESCipherCBCnoPad(false, hash); key = ac.ProcessBlock(oeValue, 0, oeValue.Length); } else { md.BlockUpdate(password, 0, Math.Min(password.Length, 127)); md.BlockUpdate(uValue, VALIDATION_SALT_OFFSET, SALT_LENGHT); md.DoFinal(hash, 0); isUserPass = CompareArray(hash, uValue, 32); if (!isUserPass) { throw new BadPasswordException(MessageLocalization.GetComposedMessage("bad.user.password")); } md.BlockUpdate(password, 0, Math.Min(password.Length, 127)); md.BlockUpdate(uValue, KEY_SALT_OFFSET, SALT_LENGHT); md.DoFinal(hash, 0); ac = new AESCipherCBCnoPad(false, hash); key = ac.ProcessBlock(ueValue, 0, ueValue.Length); } ac = new AESCipherCBCnoPad(false, key); byte[] decPerms = ac.ProcessBlock(perms, 0, perms.Length); if (decPerms[9] != (byte)'a' || decPerms[10] != (byte)'d' || decPerms[11] != (byte)'b') { throw new BadPasswordException(MessageLocalization.GetComposedMessage("bad.user.password")); } permissions = (decPerms[0] & 0xff) | ((decPerms[1] & 0xff) << 8) | ((decPerms[2] & 0xff) << 16) | ((decPerms[2] & 0xff) << 24); encryptMetadata = decPerms[8] == (byte)'T'; return(isOwnerPass); }
/** * Retrieves the page labels from a PDF as an array of {@link PdfPageLabelFormat} objects. * @param reader a PdfReader object that has the page labels you want to retrieve * @return a PdfPageLabelEntry array, containing an entry for each format change * or <code>null</code> if no page labels are present */ public static PdfPageLabelFormat[] GetPageLabelFormats(PdfReader reader) { PdfDictionary dict = reader.Catalog; PdfDictionary labels = (PdfDictionary)PdfReader.GetPdfObjectRelease(dict.Get(PdfName.PAGELABELS)); if (labels == null) { return(null); } Dictionary <int, PdfObject> numberTree = PdfNumberTree.ReadTree(labels); int[] numbers = new int[numberTree.Count]; numberTree.Keys.CopyTo(numbers, 0); Array.Sort(numbers); PdfPageLabelFormat[] formats = new PdfPageLabelFormat[numberTree.Count]; String prefix; int numberStyle; int pagecount; for (int k = 0; k < numbers.Length; ++k) { int key = numbers[k]; PdfDictionary d = (PdfDictionary)PdfReader.GetPdfObjectRelease(numberTree[key]); if (d.Contains(PdfName.ST)) { pagecount = ((PdfNumber)d.Get(PdfName.ST)).IntValue; } else { pagecount = 1; } if (d.Contains(PdfName.P)) { prefix = ((PdfString)d.Get(PdfName.P)).ToUnicodeString(); } else { prefix = ""; } if (d.Contains(PdfName.S)) { char type = ((PdfName)d.Get(PdfName.S)).ToString()[1]; switch (type) { case 'R': numberStyle = UPPERCASE_ROMAN_NUMERALS; break; case 'r': numberStyle = LOWERCASE_ROMAN_NUMERALS; break; case 'A': numberStyle = UPPERCASE_LETTERS; break; case 'a': numberStyle = LOWERCASE_LETTERS; break; default: numberStyle = DECIMAL_ARABIC_NUMERALS; break; } } else { numberStyle = EMPTY; } formats[k] = new PdfPageLabelFormat(key + 1, numberStyle, prefix, pagecount); } return(formats); }
// constructor /** * Constructs a <CODE>PdfImage</CODE>-object. * * @param image the <CODE>Image</CODE>-object * @param name the <CODE>PdfName</CODE> for this image * @throws BadPdfFormatException on error */ public PdfImage(Image image, String name, PdfIndirectReference maskRef) { if (name == null) { GenerateImgResName(image); } else { this.name = new PdfName(name); } Put(PdfName.TYPE, PdfName.XOBJECT); Put(PdfName.SUBTYPE, PdfName.IMAGE); Put(PdfName.WIDTH, new PdfNumber(image.Width)); Put(PdfName.HEIGHT, new PdfNumber(image.Height)); if (image.Layer != null) { Put(PdfName.OC, image.Layer.Ref); } if (image.IsMask() && (image.Bpc == 1 || image.Bpc > 0xff)) { Put(PdfName.IMAGEMASK, PdfBoolean.PDFTRUE); } if (maskRef != null) { if (image.Smask) { Put(PdfName.SMASK, maskRef); } else { Put(PdfName.MASK, maskRef); } } if (image.IsMask() && image.Inverted) { Put(PdfName.DECODE, new PdfLiteral("[1 0]")); } if (image.Interpolation) { Put(PdfName.INTERPOLATE, PdfBoolean.PDFTRUE); } Stream isp = null; try { // Raw Image data if (image.IsImgRaw()) { // will also have the CCITT parameters int colorspace = image.Colorspace; int[] transparency = image.Transparency; if (transparency != null && !image.IsMask() && maskRef == null) { StringBuilder s = new StringBuilder("["); for (int k = 0; k < transparency.Length; ++k) { s.Append(transparency[k]).Append(' '); } s.Append(']'); Put(PdfName.MASK, new PdfLiteral(s.ToString())); } bytes = image.RawData; Put(PdfName.LENGTH, new PdfNumber(bytes.Length)); int bpc = image.Bpc; if (bpc > 0xff) { if (!image.IsMask()) { Put(PdfName.COLORSPACE, PdfName.DEVICEGRAY); } Put(PdfName.BITSPERCOMPONENT, new PdfNumber(1)); Put(PdfName.FILTER, PdfName.CCITTFAXDECODE); int k = bpc - Image.CCITTG3_1D; PdfDictionary decodeparms = new PdfDictionary(); if (k != 0) { decodeparms.Put(PdfName.K, new PdfNumber(k)); } if ((colorspace & Image.CCITT_BLACKIS1) != 0) { decodeparms.Put(PdfName.BLACKIS1, PdfBoolean.PDFTRUE); } if ((colorspace & Image.CCITT_ENCODEDBYTEALIGN) != 0) { decodeparms.Put(PdfName.ENCODEDBYTEALIGN, PdfBoolean.PDFTRUE); } if ((colorspace & Image.CCITT_ENDOFLINE) != 0) { decodeparms.Put(PdfName.ENDOFLINE, PdfBoolean.PDFTRUE); } if ((colorspace & Image.CCITT_ENDOFBLOCK) != 0) { decodeparms.Put(PdfName.ENDOFBLOCK, PdfBoolean.PDFFALSE); } decodeparms.Put(PdfName.COLUMNS, new PdfNumber(image.Width)); decodeparms.Put(PdfName.ROWS, new PdfNumber(image.Height)); Put(PdfName.DECODEPARMS, decodeparms); } else { switch (colorspace) { case 1: Put(PdfName.COLORSPACE, PdfName.DEVICEGRAY); if (image.Inverted) { Put(PdfName.DECODE, new PdfLiteral("[1 0]")); } break; case 3: Put(PdfName.COLORSPACE, PdfName.DEVICERGB); if (image.Inverted) { Put(PdfName.DECODE, new PdfLiteral("[1 0 1 0 1 0]")); } break; case 4: default: Put(PdfName.COLORSPACE, PdfName.DEVICECMYK); if (image.Inverted) { Put(PdfName.DECODE, new PdfLiteral("[1 0 1 0 1 0 1 0]")); } break; } PdfDictionary additional = image.Additional; if (additional != null) { Merge(additional); } if (image.IsMask() && (image.Bpc == 1 || image.Bpc > 8)) { Remove(PdfName.COLORSPACE); } Put(PdfName.BITSPERCOMPONENT, new PdfNumber(image.Bpc)); if (image.Deflated) { Put(PdfName.FILTER, PdfName.FLATEDECODE); } else { FlateCompress(image.CompressionLevel); } } return; } // GIF, JPEG or PNG String errorID; if (image.RawData == null) { isp = WebRequest.Create(image.Url).GetResponse().GetResponseStream(); errorID = image.Url.ToString(); } else { isp = new MemoryStream(image.RawData); errorID = "Byte array"; } switch (image.Type) { case Image.JPEG: Put(PdfName.FILTER, PdfName.DCTDECODE); switch (image.Colorspace) { case 1: Put(PdfName.COLORSPACE, PdfName.DEVICEGRAY); break; case 3: Put(PdfName.COLORSPACE, PdfName.DEVICERGB); break; default: Put(PdfName.COLORSPACE, PdfName.DEVICECMYK); if (image.Inverted) { Put(PdfName.DECODE, new PdfLiteral("[1 0 1 0 1 0 1 0]")); } break; } Put(PdfName.BITSPERCOMPONENT, new PdfNumber(8)); if (image.RawData != null) { bytes = image.RawData; Put(PdfName.LENGTH, new PdfNumber(bytes.Length)); return; } streamBytes = new MemoryStream(); TransferBytes(isp, streamBytes, -1); break; case Image.JPEG2000: Put(PdfName.FILTER, PdfName.JPXDECODE); if (image.Colorspace > 0) { switch (image.Colorspace) { case 1: Put(PdfName.COLORSPACE, PdfName.DEVICEGRAY); break; case 3: Put(PdfName.COLORSPACE, PdfName.DEVICERGB); break; default: Put(PdfName.COLORSPACE, PdfName.DEVICECMYK); break; } Put(PdfName.BITSPERCOMPONENT, new PdfNumber(image.Bpc)); } if (image.RawData != null) { bytes = image.RawData; Put(PdfName.LENGTH, new PdfNumber(bytes.Length)); return; } streamBytes = new MemoryStream(); TransferBytes(isp, streamBytes, -1); break; case Image.JBIG2: Put(PdfName.FILTER, PdfName.JBIG2DECODE); Put(PdfName.COLORSPACE, PdfName.DEVICEGRAY); Put(PdfName.BITSPERCOMPONENT, new PdfNumber(1)); if (image.RawData != null) { bytes = image.RawData; Put(PdfName.LENGTH, new PdfNumber(bytes.Length)); return; } streamBytes = new MemoryStream(); TransferBytes(isp, streamBytes, -1); break; default: throw new IOException(MessageLocalization.GetComposedMessage("1.is.an.unknown.image.format", errorID)); } Put(PdfName.LENGTH, new PdfNumber(streamBytes.Length)); } finally { if (isp != null) { try{ isp.Close(); } catch { // empty on purpose } } } }
public PRStream(PRStream stream, PdfDictionary newDic, PdfReader reader) : this(stream, newDic) { this.reader = reader; }
/** Generates the CIDFontTyte2 dictionary. * @param fontDescriptor the indirect reference to the font descriptor * @param subsetPrefix the subset prefix * @param metrics the horizontal width metrics * @return a stream */ private PdfDictionary GetCIDFontType2(PdfIndirectReference fontDescriptor, string subsetPrefix, Object[] metrics) { PdfDictionary dic = new PdfDictionary(PdfName.FONT); // sivan; cff if (cff) { dic.Put(PdfName.SUBTYPE, PdfName.CIDFONTTYPE0); dic.Put(PdfName.BASEFONT, new PdfName(subsetPrefix + fontName + "-" + encoding)); } else { dic.Put(PdfName.SUBTYPE, PdfName.CIDFONTTYPE2); dic.Put(PdfName.BASEFONT, new PdfName(subsetPrefix + fontName)); } dic.Put(PdfName.FONTDESCRIPTOR, fontDescriptor); if (!cff) { dic.Put(PdfName.CIDTOGIDMAP, PdfName.IDENTITY); } PdfDictionary cdic = new PdfDictionary(); cdic.Put(PdfName.REGISTRY, new PdfString("Adobe")); cdic.Put(PdfName.ORDERING, new PdfString("Identity")); cdic.Put(PdfName.SUPPLEMENT, new PdfNumber(0)); dic.Put(PdfName.CIDSYSTEMINFO, cdic); if (!vertical) { dic.Put(PdfName.DW, new PdfNumber(1000)); StringBuilder buf = new StringBuilder("["); int lastNumber = -10; bool firstTime = true; for (int k = 0; k < metrics.Length; ++k) { int[] metric = (int[])metrics[k]; if (metric[1] == 1000) { continue; } int m = metric[0]; if (m == lastNumber + 1) { buf.Append(' ').Append(metric[1]); } else { if (!firstTime) { buf.Append(']'); } firstTime = false; buf.Append(m).Append('[').Append(metric[1]); } lastNumber = m; } if (buf.Length > 1) { buf.Append("]]"); dic.Put(PdfName.W, new PdfLiteral(buf.ToString())); } } return(dic); }
internal void AddDefaultColor(PdfDictionary dic) { colorDictionary.Merge(dic); }
internal override void WriteFont(PdfWriter writer, PdfIndirectReference piRef, Object[] oParams) { if (this.writer != writer) { throw new ArgumentException(MessageLocalization.GetComposedMessage("type3.font.used.with.the.wrong.pdfwriter")); } // Get first & lastchar ... int firstChar = 0; while (firstChar < usedSlot.Length && !usedSlot[firstChar]) { firstChar++; } if (firstChar == usedSlot.Length) { throw new DocumentException(MessageLocalization.GetComposedMessage("no.glyphs.defined.for.type3.font")); } int lastChar = usedSlot.Length - 1; while (lastChar >= firstChar && !usedSlot[lastChar]) { lastChar--; } int[] widths = new int[lastChar - firstChar + 1]; int[] invOrd = new int[lastChar - firstChar + 1]; int invOrdIndx = 0, w = 0; for (int u = firstChar; u <= lastChar; u++, w++) { if (usedSlot[u]) { invOrd[invOrdIndx++] = u; widths[w] = widths3[u]; } } PdfArray diffs = new PdfArray(); PdfDictionary charprocs = new PdfDictionary(); int last = -1; for (int k = 0; k < invOrdIndx; ++k) { int c = invOrd[k]; if (c > last) { last = c; diffs.Add(new PdfNumber(last)); } ++last; int c2 = invOrd[k]; String s = GlyphList.UnicodeToName(c2); if (s == null) { s = "a" + c2; } PdfName n = new PdfName(s); diffs.Add(n); Type3Glyph glyph; char2glyph.TryGetValue((char)c2, out glyph); PdfStream stream = new PdfStream(glyph.ToPdf(null)); stream.FlateCompress(compressionLevel); PdfIndirectReference refp = writer.AddToBody(stream).IndirectReference; charprocs.Put(n, refp); } PdfDictionary font = new PdfDictionary(PdfName.FONT); font.Put(PdfName.SUBTYPE, PdfName.TYPE3); if (colorized) { font.Put(PdfName.FONTBBOX, new PdfRectangle(0, 0, 0, 0)); } else { font.Put(PdfName.FONTBBOX, new PdfRectangle(llx, lly, urx, ury)); } font.Put(PdfName.FONTMATRIX, new PdfArray(new float[] { 0.001f, 0, 0, 0.001f, 0, 0 })); font.Put(PdfName.CHARPROCS, writer.AddToBody(charprocs).IndirectReference); PdfDictionary encoding = new PdfDictionary(); encoding.Put(PdfName.DIFFERENCES, diffs); font.Put(PdfName.ENCODING, writer.AddToBody(encoding).IndirectReference); font.Put(PdfName.FIRSTCHAR, new PdfNumber(firstChar)); font.Put(PdfName.LASTCHAR, new PdfNumber(lastChar)); font.Put(PdfName.WIDTHS, writer.AddToBody(new PdfArray(widths)).IndirectReference); if (pageResources.HasResources()) { font.Put(PdfName.RESOURCES, writer.AddToBody(pageResources.Resources).IndirectReference); } writer.AddToBody(font, piRef); }
internal protected virtual void WriteFont(TrueTypeFontUnicode font, PdfIndirectReference refer, Object[] parms, byte[] rotbits) { Dictionary <int, int[]> longTag = (Dictionary <int, int[]>)parms[0]; font.AddRangeUni(longTag, true, font.Subset); int[][] metrics = new int[longTag.Count][]; longTag.Values.CopyTo(metrics, 0); Array.Sort(metrics, font); PdfIndirectReference ind_font = null; PdfObject pobj = null; PdfIndirectObject obj = null; PdfIndirectReference cidset = null; // sivan: cff if (font.Cff) { byte[] b = font.ReadCffFont(); if (font.Subset || font.SubsetRanges != null) { CFFFontSubset cff = new CFFFontSubset(new RandomAccessFileOrArray(b), longTag); b = cff.Process(cff.GetNames()[0]); } pobj = new BaseFont.StreamFont(b, "CIDFontType0C", font.CompressionLevel); obj = writer.AddToBody(pobj); ind_font = obj.IndirectReference; } else { byte[] b; if (font.Subset || font.DirectoryOffset != 0) { b = font.GetSubSet(new HashSet <int>(longTag.Keys), true); } else { b = font.GetFullFont(); } int[] lengths = new int[] { b.Length }; pobj = new BaseFont.StreamFont(b, lengths, font.CompressionLevel); obj = writer.AddToBody(pobj); ind_font = obj.IndirectReference; } String subsetPrefix = ""; if (font.Subset) { subsetPrefix = TrueTypeFontUnicode.CreateSubsetPrefix(); } PdfDictionary dic = font.GetFontDescriptor(ind_font, subsetPrefix, cidset); obj = writer.AddToBody(dic); ind_font = obj.IndirectReference; pobj = font.GetCIDFontType2(ind_font, subsetPrefix, metrics); obj = writer.AddToBody(pobj); ind_font = obj.IndirectReference; pobj = font.GetToUnicode(metrics); PdfIndirectReference toUnicodeRef = null; if (pobj != null) { obj = writer.AddToBody(pobj); toUnicodeRef = obj.IndirectReference; } pobj = font.GetFontBaseType(ind_font, subsetPrefix, toUnicodeRef); writer.AddToBody(pobj, refer); }
/** Creates a new instance of DocumentFont */ internal DocumentFont(PRIndirectReference refFont) { this.refFont = refFont; font = (PdfDictionary)PdfReader.GetPdfObject(refFont); Init(); }
/** * Creates a number tree. * @param items the item of the number tree. The key is an <CODE>Integer</CODE> * and the value is a <CODE>PdfObject</CODE>. * @param writer the writer * @throws IOException on error * @return the dictionary with the number tree. */ public static PdfDictionary WriteTree <T>(Dictionary <int, T> items, PdfWriter writer) where T : PdfObject { if (items.Count == 0) { return(null); } int[] numbers = new int[items.Count]; items.Keys.CopyTo(numbers, 0); Array.Sort(numbers); if (numbers.Length <= leafSize) { PdfDictionary dic = new PdfDictionary(); PdfArray ar = new PdfArray(); for (int k = 0; k < numbers.Length; ++k) { ar.Add(new PdfNumber(numbers[k])); ar.Add(items[numbers[k]]); } dic.Put(PdfName.NUMS, ar); return(dic); } int skip = leafSize; PdfIndirectReference[] kids = new PdfIndirectReference[(numbers.Length + leafSize - 1) / leafSize]; for (int k = 0; k < kids.Length; ++k) { int offset = k * leafSize; int end = Math.Min(offset + leafSize, numbers.Length); PdfDictionary dic = new PdfDictionary(); PdfArray arr = new PdfArray(); arr.Add(new PdfNumber(numbers[offset])); arr.Add(new PdfNumber(numbers[end - 1])); dic.Put(PdfName.LIMITS, arr); arr = new PdfArray(); for (; offset < end; ++offset) { arr.Add(new PdfNumber(numbers[offset])); arr.Add(items[numbers[offset]]); } dic.Put(PdfName.NUMS, arr); kids[k] = writer.AddToBody(dic).IndirectReference; } int top = kids.Length; while (true) { if (top <= leafSize) { PdfArray arr = new PdfArray(); for (int k = 0; k < top; ++k) { arr.Add(kids[k]); } PdfDictionary dic = new PdfDictionary(); dic.Put(PdfName.KIDS, arr); return(dic); } skip *= leafSize; int tt = (numbers.Length + skip - 1) / skip; for (int k = 0; k < tt; ++k) { int offset = k * leafSize; int end = Math.Min(offset + leafSize, top); PdfDictionary dic = new PdfDictionary(); PdfArray arr = new PdfArray(); arr.Add(new PdfNumber(numbers[k * skip])); arr.Add(new PdfNumber(numbers[Math.Min((k + 1) * skip, numbers.Length) - 1])); dic.Put(PdfName.LIMITS, arr); arr = new PdfArray(); for (; offset < end; ++offset) { arr.Add(kids[offset]); } dic.Put(PdfName.KIDS, arr); kids[k] = writer.AddToBody(dic).IndirectReference; } top = tt; } }
public PdfDictionary GetEncryptionDictionary() { PdfDictionary dic = new PdfDictionary(); if (publicKeyHandler.GetRecipientsSize() > 0) { PdfArray recipients = null; dic.Put(PdfName.FILTER, PdfName.PUBSEC); dic.Put(PdfName.R, new PdfNumber(revision)); recipients = publicKeyHandler.GetEncodedRecipients(); if (revision == STANDARD_ENCRYPTION_40) { dic.Put(PdfName.V, new PdfNumber(1)); dic.Put(PdfName.SUBFILTER, PdfName.ADBE_PKCS7_S4); dic.Put(PdfName.RECIPIENTS, recipients); } else if (revision == STANDARD_ENCRYPTION_128 && encryptMetadata) { dic.Put(PdfName.V, new PdfNumber(2)); dic.Put(PdfName.LENGTH, new PdfNumber(128)); dic.Put(PdfName.SUBFILTER, PdfName.ADBE_PKCS7_S4); dic.Put(PdfName.RECIPIENTS, recipients); } else { dic.Put(PdfName.R, new PdfNumber(AES_128)); dic.Put(PdfName.V, new PdfNumber(4)); dic.Put(PdfName.SUBFILTER, PdfName.ADBE_PKCS7_S5); PdfDictionary stdcf = new PdfDictionary(); stdcf.Put(PdfName.RECIPIENTS, recipients); if (!encryptMetadata) { stdcf.Put(PdfName.ENCRYPTMETADATA, PdfBoolean.PDFFALSE); } if (revision == AES_128) { stdcf.Put(PdfName.CFM, PdfName.AESV2); } else { stdcf.Put(PdfName.CFM, PdfName.V2); } PdfDictionary cf = new PdfDictionary(); cf.Put(PdfName.DEFAULTCRYPTFILTER, stdcf); dic.Put(PdfName.CF, cf); if (embeddedFilesOnly) { dic.Put(PdfName.EFF, PdfName.DEFAULTCRYPTFILTER); dic.Put(PdfName.STRF, PdfName.IDENTITY); dic.Put(PdfName.STMF, PdfName.IDENTITY); } else { dic.Put(PdfName.STRF, PdfName.DEFAULTCRYPTFILTER); dic.Put(PdfName.STMF, PdfName.DEFAULTCRYPTFILTER); } } IDigest sh = DigestUtilities.GetDigest("SHA1"); byte[] encodedRecipient = null; byte[] seed = publicKeyHandler.GetSeed(); sh.BlockUpdate(seed, 0, seed.Length); for (int i = 0; i < publicKeyHandler.GetRecipientsSize(); i++) { encodedRecipient = publicKeyHandler.GetEncodedRecipient(i); sh.BlockUpdate(encodedRecipient, 0, encodedRecipient.Length); } if (!encryptMetadata) { sh.BlockUpdate(metadataPad, 0, metadataPad.Length); } byte[] mdResult = new byte[sh.GetDigestSize()]; sh.DoFinal(mdResult, 0); SetupByEncryptionKey(mdResult, keyLength); } else { dic.Put(PdfName.FILTER, PdfName.STANDARD); dic.Put(PdfName.O, new PdfLiteral(PdfContentByte.EscapeString(ownerKey))); dic.Put(PdfName.U, new PdfLiteral(PdfContentByte.EscapeString(userKey))); dic.Put(PdfName.P, new PdfNumber(permissions)); dic.Put(PdfName.R, new PdfNumber(revision)); if (revision == STANDARD_ENCRYPTION_40) { dic.Put(PdfName.V, new PdfNumber(1)); } else if (revision == STANDARD_ENCRYPTION_128 && encryptMetadata) { dic.Put(PdfName.V, new PdfNumber(2)); dic.Put(PdfName.LENGTH, new PdfNumber(128)); } else { if (!encryptMetadata) { dic.Put(PdfName.ENCRYPTMETADATA, PdfBoolean.PDFFALSE); } dic.Put(PdfName.R, new PdfNumber(AES_128)); dic.Put(PdfName.V, new PdfNumber(4)); dic.Put(PdfName.LENGTH, new PdfNumber(128)); PdfDictionary stdcf = new PdfDictionary(); stdcf.Put(PdfName.LENGTH, new PdfNumber(16)); if (embeddedFilesOnly) { stdcf.Put(PdfName.AUTHEVENT, PdfName.EFOPEN); dic.Put(PdfName.EFF, PdfName.STDCF); dic.Put(PdfName.STRF, PdfName.IDENTITY); dic.Put(PdfName.STMF, PdfName.IDENTITY); } else { stdcf.Put(PdfName.AUTHEVENT, PdfName.DOCOPEN); dic.Put(PdfName.STRF, PdfName.STDCF); dic.Put(PdfName.STMF, PdfName.STDCF); } if (revision == AES_128) { stdcf.Put(PdfName.CFM, PdfName.AESV2); } else { stdcf.Put(PdfName.CFM, PdfName.V2); } PdfDictionary cf = new PdfDictionary(); cf.Put(PdfName.STDCF, stdcf); dic.Put(PdfName.CF, cf); } } return(dic); }
internal static void MergeResources(PdfDictionary result, PdfDictionary source) { MergeResources(result, source, null); }
/** Outputs to the writer the font dictionaries and streams. * @param writer the writer for this document * @param ref the font indirect reference * @param parms several parameters that depend on the font type * @throws IOException on error * @throws DocumentException error in generating the object */ internal override void WriteFont(PdfWriter writer, PdfIndirectReference piref, Object[] parms) { Dictionary <int, int[]> longTag = (Dictionary <int, int[]>)parms[0]; AddRangeUni(longTag, true, subset); int[][] metrics = new int[longTag.Count][]; longTag.Values.CopyTo(metrics, 0); Array.Sort(metrics, this); PdfIndirectReference ind_font = null; PdfObject pobj = null; PdfIndirectObject obj = null; PdfIndirectReference cidset = null; if (writer.PDFXConformance == PdfWriter.PDFA1A || writer.PDFXConformance == PdfWriter.PDFA1B) { PdfStream stream; if (metrics.Length == 0) { stream = new PdfStream(new byte[] { (byte)0x80 }); } else { int top = metrics[metrics.Length - 1][0]; byte[] bt = new byte[top / 8 + 1]; int length = metrics.GetLength(0); for (int k = 0; k < length; ++k) { int v = metrics[k][0]; bt[v / 8] |= rotbits[v % 8]; } stream = new PdfStream(bt); stream.FlateCompress(compressionLevel); } cidset = writer.AddToBody(stream).IndirectReference; } // sivan: cff if (cff) { byte[] b = ReadCffFont(); if (subset || subsetRanges != null) { CFFFontSubset cffs = new CFFFontSubset(new RandomAccessFileOrArray(b), longTag); b = cffs.Process((cffs.GetNames())[0]); } pobj = new StreamFont(b, "CIDFontType0C", compressionLevel); obj = writer.AddToBody(pobj); ind_font = obj.IndirectReference; } else { byte[] b; if (subset || directoryOffset != 0) { TrueTypeFontSubSet sb = new TrueTypeFontSubSet(fileName, new RandomAccessFileOrArray(rf), longTag, directoryOffset, false, false); b = sb.Process(); } else { b = GetFullFont(); } int[] lengths = new int[] { b.Length }; pobj = new StreamFont(b, lengths, compressionLevel); obj = writer.AddToBody(pobj); ind_font = obj.IndirectReference; } String subsetPrefix = ""; if (subset) { subsetPrefix = CreateSubsetPrefix(); } PdfDictionary dic = GetFontDescriptor(ind_font, subsetPrefix, cidset); obj = writer.AddToBody(dic); ind_font = obj.IndirectReference; pobj = GetCIDFontType2(ind_font, subsetPrefix, metrics); obj = writer.AddToBody(pobj); ind_font = obj.IndirectReference; pobj = GetToUnicode(metrics); PdfIndirectReference toUnicodeRef = null; if (pobj != null) { obj = writer.AddToBody(pobj); toUnicodeRef = obj.IndirectReference; } pobj = GetFontBaseType(ind_font, subsetPrefix, toUnicodeRef); writer.AddToBody(pobj, piref); }
/** * Gets the button appearance. * @throws IOException on error * @throws DocumentException on error * @return the button appearance */ virtual public PdfAppearance GetAppearance() { PdfAppearance app = GetBorderAppearance(); Rectangle box = new Rectangle(app.BoundingBox); if ((text == null || text.Length == 0) && (layout == LAYOUT_LABEL_ONLY || (image == null && template == null && iconReference == null))) { return(app); } if (layout == LAYOUT_ICON_ONLY && image == null && template == null && iconReference == null) { return(app); } BaseFont ufont = RealFont; bool borderExtra = borderStyle == PdfBorderDictionary.STYLE_BEVELED || borderStyle == PdfBorderDictionary.STYLE_INSET; float h = box.Height - borderWidth * 2; float bw2 = borderWidth; if (borderExtra) { h -= borderWidth * 2; bw2 *= 2; } float offsetX = (borderExtra ? 2 * borderWidth : borderWidth); offsetX = Math.Max(offsetX, 1); float offX = Math.Min(bw2, offsetX); tp = null; float textX = float.NaN; float textY = 0; float fsize = fontSize; float wt = box.Width - 2 * offX - 2; float ht = box.Height - 2 * offX; float adj = (iconFitToBounds ? 0 : offX + 1); int nlayout = layout; if (image == null && template == null && iconReference == null) { nlayout = LAYOUT_LABEL_ONLY; } Rectangle iconBox = null; while (true) { switch (nlayout) { case LAYOUT_LABEL_ONLY: case LAYOUT_LABEL_OVER_ICON: if (text != null && text.Length > 0 && wt > 0 && ht > 0) { fsize = CalculateFontSize(wt, ht); textX = (box.Width - ufont.GetWidthPoint(text, fsize)) / 2; textY = (box.Height - ufont.GetFontDescriptor(BaseFont.ASCENT, fsize)) / 2; } goto case LAYOUT_ICON_ONLY; case LAYOUT_ICON_ONLY: if (nlayout == LAYOUT_LABEL_OVER_ICON || nlayout == LAYOUT_ICON_ONLY) { iconBox = new Rectangle(box.Left + adj, box.Bottom + adj, box.Right - adj, box.Top - adj); } break; case LAYOUT_ICON_TOP_LABEL_BOTTOM: if (text == null || text.Length == 0 || wt <= 0 || ht <= 0) { nlayout = LAYOUT_ICON_ONLY; continue; } float nht = box.Height * 0.35f - offX; if (nht > 0) { fsize = CalculateFontSize(wt, nht); } else { fsize = 4; } textX = (box.Width - ufont.GetWidthPoint(text, fsize)) / 2; textY = offX - ufont.GetFontDescriptor(BaseFont.DESCENT, fsize); iconBox = new Rectangle(box.Left + adj, textY + fsize, box.Right - adj, box.Top - adj); break; case LAYOUT_LABEL_TOP_ICON_BOTTOM: if (text == null || text.Length == 0 || wt <= 0 || ht <= 0) { nlayout = LAYOUT_ICON_ONLY; continue; } nht = box.Height * 0.35f - offX; if (nht > 0) { fsize = CalculateFontSize(wt, nht); } else { fsize = 4; } textX = (box.Width - ufont.GetWidthPoint(text, fsize)) / 2; textY = box.Height - offX - fsize; if (textY < offX) { textY = offX; } iconBox = new Rectangle(box.Left + adj, box.Bottom + adj, box.Right - adj, textY + ufont.GetFontDescriptor(BaseFont.DESCENT, fsize)); break; case LAYOUT_LABEL_LEFT_ICON_RIGHT: if (text == null || text.Length == 0 || wt <= 0 || ht <= 0) { nlayout = LAYOUT_ICON_ONLY; continue; } float nw = box.Width * 0.35f - offX; if (nw > 0) { fsize = CalculateFontSize(wt, nw); } else { fsize = 4; } if (ufont.GetWidthPoint(text, fsize) >= wt) { nlayout = LAYOUT_LABEL_ONLY; fsize = fontSize; continue; } textX = offX + 1; textY = (box.Height - ufont.GetFontDescriptor(BaseFont.ASCENT, fsize)) / 2; iconBox = new Rectangle(textX + ufont.GetWidthPoint(text, fsize), box.Bottom + adj, box.Right - adj, box.Top - adj); break; case LAYOUT_ICON_LEFT_LABEL_RIGHT: if (text == null || text.Length == 0 || wt <= 0 || ht <= 0) { nlayout = LAYOUT_ICON_ONLY; continue; } nw = box.Width * 0.35f - offX; if (nw > 0) { fsize = CalculateFontSize(wt, nw); } else { fsize = 4; } if (ufont.GetWidthPoint(text, fsize) >= wt) { nlayout = LAYOUT_LABEL_ONLY; fsize = fontSize; continue; } textX = box.Width - ufont.GetWidthPoint(text, fsize) - offX - 1; textY = (box.Height - ufont.GetFontDescriptor(BaseFont.ASCENT, fsize)) / 2; iconBox = new Rectangle(box.Left + adj, box.Bottom + adj, textX - 1, box.Top - adj); break; } break; } if (textY < box.Bottom + offX) { textY = box.Bottom + offX; } if (iconBox != null && (iconBox.Width <= 0 || iconBox.Height <= 0)) { iconBox = null; } bool haveIcon = false; float boundingBoxWidth = 0; float boundingBoxHeight = 0; PdfArray matrix = null; if (iconBox != null) { if (image != null) { tp = new PdfTemplate(writer); tp.BoundingBox = new Rectangle(image); writer.AddDirectTemplateSimple(tp, PdfName.FRM); tp.AddImage(image, image.Width, 0, 0, image.Height, 0, 0); haveIcon = true; boundingBoxWidth = tp.BoundingBox.Width; boundingBoxHeight = tp.BoundingBox.Height; } else if (template != null) { tp = new PdfTemplate(writer); tp.BoundingBox = new Rectangle(template.Width, template.Height); writer.AddDirectTemplateSimple(tp, PdfName.FRM); tp.AddTemplate(template, template.BoundingBox.Left, template.BoundingBox.Bottom); haveIcon = true; boundingBoxWidth = tp.BoundingBox.Width; boundingBoxHeight = tp.BoundingBox.Height; } else if (iconReference != null) { PdfDictionary dic = (PdfDictionary)PdfReader.GetPdfObject(iconReference); if (dic != null) { Rectangle r2 = PdfReader.GetNormalizedRectangle(dic.GetAsArray(PdfName.BBOX)); matrix = dic.GetAsArray(PdfName.MATRIX); haveIcon = true; boundingBoxWidth = r2.Width; boundingBoxHeight = r2.Height; } } } if (haveIcon) { float icx = iconBox.Width / boundingBoxWidth; float icy = iconBox.Height / boundingBoxHeight; if (proportionalIcon) { switch (scaleIcon) { case SCALE_ICON_IS_TOO_BIG: icx = Math.Min(icx, icy); icx = Math.Min(icx, 1); break; case SCALE_ICON_IS_TOO_SMALL: icx = Math.Min(icx, icy); icx = Math.Max(icx, 1); break; case SCALE_ICON_NEVER: icx = 1; break; default: icx = Math.Min(icx, icy); break; } icy = icx; } else { switch (scaleIcon) { case SCALE_ICON_IS_TOO_BIG: icx = Math.Min(icx, 1); icy = Math.Min(icy, 1); break; case SCALE_ICON_IS_TOO_SMALL: icx = Math.Max(icx, 1); icy = Math.Max(icy, 1); break; case SCALE_ICON_NEVER: icx = icy = 1; break; default: break; } } float xpos = iconBox.Left + (iconBox.Width - (boundingBoxWidth * icx)) * iconHorizontalAdjustment; float ypos = iconBox.Bottom + (iconBox.Height - (boundingBoxHeight * icy)) * iconVerticalAdjustment; app.SaveState(); app.Rectangle(iconBox.Left, iconBox.Bottom, iconBox.Width, iconBox.Height); app.Clip(); app.NewPath(); if (tp != null) { app.AddTemplate(tp, icx, 0, 0, icy, xpos, ypos); } else { float cox = 0; float coy = 0; if (matrix != null && matrix.Size == 6) { PdfNumber nm = matrix.GetAsNumber(4); if (nm != null) { cox = nm.FloatValue; } nm = matrix.GetAsNumber(5); if (nm != null) { coy = nm.FloatValue; } } app.AddTemplateReference(iconReference, PdfName.FRM, icx, 0, 0, icy, xpos - cox * icx, ypos - coy * icy); } app.RestoreState(); } if (!float.IsNaN(textX)) { app.SaveState(); app.Rectangle(offX, offX, box.Width - 2 * offX, box.Height - 2 * offX); app.Clip(); app.NewPath(); if (textColor == null) { app.ResetGrayFill(); } else { app.SetColorFill(textColor); } app.BeginText(); app.SetFontAndSize(ufont, fsize); app.SetTextMatrix(textX, textY); app.ShowText(text); app.EndText(); app.RestoreState(); } return(app); }
virtual public String[] GetFieldValues(String name) { PdfDictionary field = GetField(name); if (field == null) { return new String[] { } } ; PdfObject v = GetPdfObject(field.Get(PdfName.V)); if (v == null) { return new String[] { } } ; if (v.IsName()) { return new String[] { PdfName.DecodeName(((PdfName)v).ToString()) } } ; else if (v.IsString()) { PdfString vs = (PdfString)v; if (encoding == null || vs.Encoding != null) { return new String[] { vs.ToUnicodeString() } } ; byte[] b = vs.GetBytes(); if (b.Length >= 2 && b[0] == (byte)254 && b[1] == (byte)255) { return new String[] { vs.ToUnicodeString() } } ; try { if (encoding.Equals(PdfName.SHIFT_JIS)) { return new String[] { Encoding.GetEncoding(932).GetString(b) } } ; else if (encoding.Equals(PdfName.UHC)) { return new String[] { Encoding.GetEncoding(949).GetString(b) } } ; else if (encoding.Equals(PdfName.GBK)) { return new String[] { Encoding.GetEncoding(936).GetString(b) } } ; else if (encoding.Equals(PdfName.BIGFIVE)) { return new String[] { Encoding.GetEncoding(950).GetString(b) } } ; else if (encoding.Equals(PdfName.UTF_8)) { return new String[] { Encoding.UTF8.GetString(b) } } ; } catch { } return(new String[] { vs.ToUnicodeString() }); } else if (v.IsArray()) { PdfArray vsArray = (PdfArray)v; System.Collections.Generic.List <String> vals = new System.Collections.Generic.List <String>(); for (Int32 vsIdx = 0; vsIdx < vsArray.Size; vsIdx++) { if (vsArray[vsIdx] == null) { vals.Add(""); } else if (vsArray[vsIdx].IsString()) { PdfString vs = (PdfString)vsArray[vsIdx]; if (encoding == null || vs.Encoding != null) { vals.Add(vs.ToUnicodeString()); } else { byte[] b1 = vs.GetBytes(); if (b1.Length >= 2 && b1[0] == (byte)254 && b1[1] == (byte)255) { vals.Add(vs.ToUnicodeString()); } else { try { if (encoding.Equals(PdfName.SHIFT_JIS)) { vals.Add(Encoding.GetEncoding(932).GetString(b1)); } else if (encoding.Equals(PdfName.UHC)) { vals.Add(Encoding.GetEncoding(949).GetString(b1)); } else if (encoding.Equals(PdfName.GBK)) { vals.Add(Encoding.GetEncoding(936).GetString(b1)); } else if (encoding.Equals(PdfName.BIGFIVE)) { vals.Add(Encoding.GetEncoding(950).GetString(b1)); } else if (encoding.Equals(PdfName.UTF_8)) { vals.Add(Encoding.UTF8.GetString(b1)); } } catch { } } } } else if (vsArray[vsIdx].IsName()) { vals.Add(PdfName.DecodeName(((PdfName)vsArray[vsIdx]).ToString())); } } return(vals.ToArray()); } return(new String[] { }); }
/** * @see com.lowagie.text.pdf.PdfDictionary#toPdf(com.lowagie.text.pdf.PdfWriter, java.io.OutputStream) */ public override void ToPdf(PdfWriter writer, Stream os) { if (inputStream != null && compressed) { Put(PdfName.FILTER, PdfName.FLATEDECODE); } PdfEncryption crypto = null; if (writer != null) { crypto = writer.Encryption; } if (crypto != null) { PdfObject filter = Get(PdfName.FILTER); if (filter != null) { if (PdfName.CRYPT.Equals(filter)) { crypto = null; } else if (filter.IsArray()) { PdfArray a = (PdfArray)filter; if (!a.IsEmpty() && PdfName.CRYPT.Equals(a[0])) { crypto = null; } } } } if (crypto != null && crypto.IsEmbeddedFilesOnly()) { PdfArray filter = new PdfArray(); PdfArray decodeparms = new PdfArray(); PdfDictionary crypt = new PdfDictionary(); crypt.Put(PdfName.NAME, PdfName.STDCF); filter.Add(PdfName.CRYPT); decodeparms.Add(crypt); if (compressed) { filter.Add(PdfName.FLATEDECODE); decodeparms.Add(new PdfNull()); } Put(PdfName.FILTER, filter); Put(PdfName.DECODEPARMS, decodeparms); } PdfObject nn = Get(PdfName.LENGTH); if (crypto != null && nn != null && nn.IsNumber()) { int sz = ((PdfNumber)nn).IntValue; Put(PdfName.LENGTH, new PdfNumber(crypto.CalculateStreamSize(sz))); SuperToPdf(writer, os); Put(PdfName.LENGTH, nn); } else { SuperToPdf(writer, os); } os.Write(STARTSTREAM, 0, STARTSTREAM.Length); if (inputStream != null) { rawLength = 0; ZDeflaterOutputStream def = null; OutputStreamCounter osc = new OutputStreamCounter(os); OutputStreamEncryption ose = null; Stream fout = osc; if (crypto != null) { fout = ose = crypto.GetEncryptionStream(fout); } if (compressed) { fout = def = new ZDeflaterOutputStream(fout, compressionLevel); } byte[] buf = new byte[4192]; while (true) { int n = inputStream.Read(buf, 0, buf.Length); if (n <= 0) { break; } fout.Write(buf, 0, n); rawLength += n; } if (def != null) { def.Finish(); } if (ose != null) { ose.Finish(); } inputStreamLength = (int)osc.Counter; } else { if (crypto == null) { if (streamBytes != null) { streamBytes.WriteTo(os); } else { os.Write(bytes, 0, bytes.Length); } } else { byte[] b; if (streamBytes != null) { b = crypto.EncryptByteArray(streamBytes.ToArray()); } else { b = crypto.EncryptByteArray(bytes); } os.Write(b, 0, b.Length); } } os.Write(ENDSTREAM, 0, ENDSTREAM.Length); }
private void DoType1TT() { PdfObject enc = PdfReader.GetPdfObject(font.Get(PdfName.ENCODING)); if (enc == null) { FillEncoding(null); } else { if (enc.IsName()) { FillEncoding((PdfName)enc); } else { PdfDictionary encDic = (PdfDictionary)enc; enc = PdfReader.GetPdfObject(encDic.Get(PdfName.BASEENCODING)); if (enc == null) { FillEncoding(null); } else { FillEncoding((PdfName)enc); } PdfArray diffs = encDic.GetAsArray(PdfName.DIFFERENCES); if (diffs != null) { diffmap = new IntHashtable(); int currentNumber = 0; for (int k = 0; k < diffs.Size; ++k) { PdfObject obj = diffs[k]; if (obj.IsNumber()) { currentNumber = ((PdfNumber)obj).IntValue; } else { int[] c = GlyphList.NameToUnicode(PdfName.DecodeName(((PdfName)obj).ToString())); if (c != null && c.Length > 0) { uni2byte[c[0]] = currentNumber; diffmap[c[0]] = currentNumber; } ++currentNumber; } } } } } PdfArray newWidths = font.GetAsArray(PdfName.WIDTHS); PdfNumber first = font.GetAsNumber(PdfName.FIRSTCHAR); PdfNumber last = font.GetAsNumber(PdfName.LASTCHAR); if (BuiltinFonts14.ContainsKey(fontName)) { BaseFont bf; bf = BaseFont.CreateFont(fontName, WINANSI, false); int[] e = uni2byte.ToOrderedKeys(); for (int k = 0; k < e.Length; ++k) { int n = uni2byte[e[k]]; widths[n] = bf.GetRawWidth(n, GlyphList.UnicodeToName(e[k])); } if (diffmap != null) //widths for differences must override existing ones { e = diffmap.ToOrderedKeys(); for (int k = 0; k < e.Length; ++k) { int n = diffmap[e[k]]; widths[n] = bf.GetRawWidth(n, GlyphList.UnicodeToName(e[k])); } diffmap = null; } Ascender = bf.GetFontDescriptor(ASCENT, 1000); CapHeight = bf.GetFontDescriptor(CAPHEIGHT, 1000); Descender = bf.GetFontDescriptor(DESCENT, 1000); ItalicAngle = bf.GetFontDescriptor(ITALICANGLE, 1000); llx = bf.GetFontDescriptor(BBOXLLX, 1000); lly = bf.GetFontDescriptor(BBOXLLY, 1000); urx = bf.GetFontDescriptor(BBOXURX, 1000); ury = bf.GetFontDescriptor(BBOXURY, 1000); } if (first != null && last != null && newWidths != null) { int f = first.IntValue; for (int k = 0; k < newWidths.Size; ++k) { widths[f + k] = newWidths.GetAsNumber(k).IntValue; } } FillFontDesc(font.GetAsDict(PdfName.FONTDESCRIPTOR)); }
/** Generates the font dictionary for this font. * @return the PdfDictionary containing the font dictionary * @param firstChar the first valid character * @param lastChar the last valid character * @param shortTag a 256 bytes long <CODE>byte</CODE> array where each unused byte is represented by 0 * @param fontDescriptor the indirect reference to a PdfDictionary containing the font descriptor or <CODE>null</CODE> */ private PdfDictionary GetFontBaseType(PdfIndirectReference fontDescriptor, int firstChar, int lastChar, byte[] shortTag) { PdfDictionary dic = new PdfDictionary(PdfName.FONT); dic.Put(PdfName.SUBTYPE, PdfName.TYPE1); dic.Put(PdfName.BASEFONT, new PdfName(FontName)); bool stdEncoding = encoding.Equals(CP1252) || encoding.Equals(MACROMAN); if (!fontSpecific || specialMap != null) { for (int k = firstChar; k <= lastChar; ++k) { if (!differences[k].Equals(notdef)) { firstChar = k; break; } } if (stdEncoding) { dic.Put(PdfName.ENCODING, encoding.Equals(CP1252) ? PdfName.WIN_ANSI_ENCODING : PdfName.MAC_ROMAN_ENCODING); } else { PdfDictionary enc = new PdfDictionary(PdfName.ENCODING); PdfArray dif = new PdfArray(); bool gap = true; for (int k = firstChar; k <= lastChar; ++k) { if (shortTag[k] != 0) { if (gap) { dif.Add(new PdfNumber(k)); gap = false; } dif.Add(new PdfName(differences[k])); } else { gap = true; } } enc.Put(PdfName.DIFFERENCES, dif); dic.Put(PdfName.ENCODING, enc); } } if (specialMap != null || forceWidthsOutput || !(builtinFont && (fontSpecific || stdEncoding))) { dic.Put(PdfName.FIRSTCHAR, new PdfNumber(firstChar)); dic.Put(PdfName.LASTCHAR, new PdfNumber(lastChar)); PdfArray wd = new PdfArray(); for (int k = firstChar; k <= lastChar; ++k) { if (shortTag[k] == 0) { wd.Add(new PdfNumber(0)); } else { wd.Add(new PdfNumber(widths[k])); } } dic.Put(PdfName.WIDTHS, wd); } if (!builtinFont && fontDescriptor != null) { dic.Put(PdfName.FONTDESCRIPTOR, fontDescriptor); } return(dic); }
/// <summary> /// Creates a name tree. /// and the value is a PdfObject . Note that although the /// keys are strings only the lower byte is used and no check is made for chars /// with the same lower byte and different upper byte. This will generate a wrong /// tree name. /// @throws IOException on error /// generally pointed to by the key /Dests, for example /// </summary> /// <param name="items">the item of the name tree. The key is a String </param> /// <param name="writer">the writer</param> /// <returns>the dictionary with the name tree. This dictionary is the one</returns> public static PdfDictionary WriteTree(Hashtable items, PdfWriter writer) { if (items.Count == 0) { return(null); } string[] names = new string[items.Count]; items.Keys.CopyTo(names, 0); Array.Sort(names); if (names.Length <= LeafSize) { PdfDictionary dic = new PdfDictionary(); PdfArray ar = new PdfArray(); for (int k = 0; k < names.Length; ++k) { ar.Add(new PdfString(names[k], null)); ar.Add((PdfObject)items[names[k]]); } dic.Put(PdfName.Names, ar); return(dic); } int skip = LeafSize; PdfIndirectReference[] kids = new PdfIndirectReference[(names.Length + LeafSize - 1) / LeafSize]; for (int k = 0; k < kids.Length; ++k) { int offset = k * LeafSize; int end = Math.Min(offset + LeafSize, names.Length); PdfDictionary dic = new PdfDictionary(); PdfArray arr = new PdfArray(); arr.Add(new PdfString(names[offset], null)); arr.Add(new PdfString(names[end - 1], null)); dic.Put(PdfName.Limits, arr); arr = new PdfArray(); for (; offset < end; ++offset) { arr.Add(new PdfString(names[offset], null)); arr.Add((PdfObject)items[names[offset]]); } dic.Put(PdfName.Names, arr); kids[k] = writer.AddToBody(dic).IndirectReference; } int top = kids.Length; while (true) { if (top <= LeafSize) { PdfArray arr = new PdfArray(); for (int k = 0; k < top; ++k) { arr.Add(kids[k]); } PdfDictionary dic = new PdfDictionary(); dic.Put(PdfName.Kids, arr); return(dic); } skip *= LeafSize; int tt = (names.Length + skip - 1) / skip; for (int k = 0; k < tt; ++k) { int offset = k * LeafSize; int end = Math.Min(offset + LeafSize, top); PdfDictionary dic = new PdfDictionary(); PdfArray arr = new PdfArray(); arr.Add(new PdfString(names[k * skip], null)); arr.Add(new PdfString(names[Math.Min((k + 1) * skip, names.Length) - 1], null)); dic.Put(PdfName.Limits, arr); arr = new PdfArray(); for (; offset < end; ++offset) { arr.Add(kids[offset]); } dic.Put(PdfName.Kids, arr); kids[k] = writer.AddToBody(dic).IndirectReference; } top = tt; } }
// returns the top parent to include in the catalog internal PdfIndirectReference WritePageTree() { if (pages.Count == 0) { throw new IOException(MessageLocalization.GetComposedMessage("the.document.has.no.pages")); } int leaf = 1; List <PdfIndirectReference> tParents = parents; List <PdfIndirectReference> tPages = pages; List <PdfIndirectReference> nextParents = new List <PdfIndirectReference>(); while (true) { leaf *= leafSize; int stdCount = leafSize; int rightCount = tPages.Count % leafSize; if (rightCount == 0) { rightCount = leafSize; } for (int p = 0; p < tParents.Count; ++p) { int count; int thisLeaf = leaf; if (p == tParents.Count - 1) { count = rightCount; thisLeaf = pages.Count % leaf; if (thisLeaf == 0) { thisLeaf = leaf; } } else { count = stdCount; } PdfDictionary top = new PdfDictionary(PdfName.PAGES); top.Put(PdfName.COUNT, new PdfNumber(thisLeaf)); PdfArray kids = new PdfArray(); List <PdfObject> intern = kids.ArrayList; foreach (PdfObject obb in tPages.GetRange(p * stdCount, count)) { intern.Add(obb); } top.Put(PdfName.KIDS, kids); if (tParents.Count > 1) { if ((p % leafSize) == 0) { nextParents.Add(writer.PdfIndirectReference); } top.Put(PdfName.PARENT, nextParents[p / leafSize]); } writer.AddToBody(top, tParents[p]); } if (tParents.Count == 1) { topParent = tParents[0]; return(topParent); } tPages = tParents; tParents = nextParents; nextParents = new List <PdfIndirectReference>(); } }
/** * Retrieves the page labels from a PDF as an array of String objects. * @param reader a PdfReader object that has the page labels you want to retrieve * @return a String array or <code>null</code> if no page labels are present */ public static String[] GetPageLabels(PdfReader reader) { int n = reader.NumberOfPages; PdfDictionary dict = reader.Catalog; PdfDictionary labels = (PdfDictionary)PdfReader.GetPdfObjectRelease(dict.Get(PdfName.PAGELABELS)); if (labels == null) { return(null); } String[] labelstrings = new String[n]; Dictionary <int, PdfObject> numberTree = PdfNumberTree.ReadTree(labels); int pagecount = 1; String prefix = ""; char type = 'D'; for (int i = 0; i < n; i++) { if (numberTree.ContainsKey(i)) { PdfDictionary d = (PdfDictionary)PdfReader.GetPdfObjectRelease(numberTree[i]); if (d.Contains(PdfName.ST)) { pagecount = ((PdfNumber)d.Get(PdfName.ST)).IntValue; } else { pagecount = 1; } if (d.Contains(PdfName.P)) { prefix = ((PdfString)d.Get(PdfName.P)).ToUnicodeString(); } if (d.Contains(PdfName.S)) { type = ((PdfName)d.Get(PdfName.S)).ToString()[1]; } else { type = 'e'; } } switch (type) { default: labelstrings[i] = prefix + pagecount; break; case 'R': labelstrings[i] = prefix + RomanNumberFactory.GetUpperCaseString(pagecount); break; case 'r': labelstrings[i] = prefix + RomanNumberFactory.GetLowerCaseString(pagecount); break; case 'A': labelstrings[i] = prefix + RomanAlphabetFactory.GetUpperCaseString(pagecount); break; case 'a': labelstrings[i] = prefix + RomanAlphabetFactory.GetLowerCaseString(pagecount); break; case 'e': labelstrings[i] = prefix; break; } pagecount++; } return(labelstrings); }
public CMapAwareDocumentFont(PdfDictionary font) : base(font) { fontDic = font; InitFont(); }
public byte[] Decode(byte[] b, PdfName filterName, PdfObject decodeParams, PdfDictionary streamDictionary) { // allocate the output buffer MemoryStream baos = new MemoryStream(); sbyte dupCount = -1; for (int i = 0; i < b.Length; i++) { dupCount = (sbyte)b[i]; if (dupCount == -128) { break; // this is implicit end of data } if (dupCount >= 0 && dupCount <= 127) { int bytesToCopy = dupCount + 1; baos.Write(b, i, bytesToCopy); i += bytesToCopy; } else { // make dupcount copies of the next byte i++; for (int j = 0; j < 1 - (int)(dupCount); j++) { baos.WriteByte(b[i]); } } } return(baos.ToArray()); }
/** * Creates an instance of a CMapAwareFont based on an indirect reference to a font. * @param refFont the indirect reference to a font */ public CMapAwareDocumentFont(PRIndirectReference refFont) : base(refFont) { fontDic = (PdfDictionary)PdfReader.GetPdfObjectRelease(refFont); InitFont(); }
public void Push(PdfDictionary resources) { _resourceStack.Add(resources); }
/** Creates a new instance of DocumentFont */ internal DocumentFont(PdfDictionary font) { this.refFont = null; this.font = font; Init(); }
/** * Resets the additional pageDictEntries. * @since 5.1.0 */ public void ResetPageDictEntries() { pageDictEntries = new PdfDictionary(); }
protected void BuildStructTreeRootForTagged(PdfDictionary catalog) { if (tagged) { this.StructureTreeRoot.BuildTree(); catalog.Put(PdfName.STRUCTTREEROOT, structureTreeRoot.Reference); PdfDictionary mi = new PdfDictionary(); mi.Put(PdfName.MARKED, PdfBoolean.PDFTRUE); if (userProperties) mi.Put(PdfName.USERPROPERTIES, PdfBoolean.PDFTRUE); catalog.Put(PdfName.MARKINFO, mi); } }
internal void AddDefaultColorDiff(PdfDictionary dic) { colorDictionary.MergeDifferent(dic); }
private void CompleteExtraCatalog(PdfDictionary extraCatalog) { if (IsPdfX()) { if (extraCatalog.Get(PdfName.OUTPUTINTENTS) == null) { PdfDictionary outD = new PdfDictionary(PdfName.OUTPUTINTENT); outD.Put(PdfName.OUTPUTCONDITION, new PdfString("SWOP CGATS TR 001-1995")); outD.Put(PdfName.OUTPUTCONDITIONIDENTIFIER, new PdfString("CGATS TR 001")); outD.Put(PdfName.REGISTRYNAME, new PdfString("http://www.color.org")); outD.Put(PdfName.INFO, new PdfString("")); outD.Put(PdfName.S, PdfName.GTS_PDFX); extraCatalog.Put(PdfName.OUTPUTINTENTS, new PdfArray(outD)); } } }
private void CompleteInfoDictionary(PdfDictionary info) { if (IsPdfX()) { if (info.Get(PdfName.GTS_PDFXVERSION) == null) { if (((PdfXConformanceImp)pdfIsoConformance).IsPdfX1A2001()) { info.Put(PdfName.GTS_PDFXVERSION, new PdfString("PDF/X-1:2001")); info.Put(new PdfName("GTS_PDFXConformance"), new PdfString("PDF/X-1a:2001")); } else if (((PdfXConformanceImp)pdfIsoConformance).IsPdfX32002()) info.Put(PdfName.GTS_PDFXVERSION, new PdfString("PDF/X-3:2002")); } if (info.Get(PdfName.TITLE) == null) { info.Put(PdfName.TITLE, new PdfString("Pdf document")); } if (info.Get(PdfName.CREATOR) == null) { info.Put(PdfName.CREATOR, new PdfString("Unknown")); } if (info.Get(PdfName.TRAPPED) == null) { info.Put(PdfName.TRAPPED, new PdfName("False")); } } }
internal protected virtual XmpWriter GetXmpWriter(MemoryStream baos, PdfDictionary info) { if (xmpWriter == null) xmpWriter = new XmpWriter(baos, info); return xmpWriter; }
private static PdfObject FindImageInPDFDictionary(PdfDictionary pg) { PdfDictionary res = (PdfDictionary)PdfReader.GetPdfObject(pg.Get(PdfName.RESOURCES)); PdfDictionary xobj = (PdfDictionary)PdfReader.GetPdfObject(res.Get(PdfName.XOBJECT)); if (xobj != null) { foreach (PdfName name in xobj.Keys) { PdfObject obj = xobj.Get(name); if (obj.IsIndirect()) { PdfDictionary tg = (PdfDictionary)PdfReader.GetPdfObject(obj); PdfName type = (PdfName)PdfReader.GetPdfObject(tg.Get(PdfName.SUBTYPE)); //image at the root of the pdf if (PdfName.IMAGE.Equals(type)) { return obj; }// image inside a form else if (PdfName.FORM.Equals(type)) { return FindImageInPDFDictionary(tg); } //image inside a group else if (PdfName.GROUP.Equals(type)) { return FindImageInPDFDictionary(tg); } } } } return null; }
private static AttachmentFile extractFile(PdfDictionary filespec) { if (filespec == null) return null; var type = PdfReader.GetPdfObject(filespec.Get(PdfName.TYPE)) as PdfName; if (!PdfName.F.Equals(type) && !PdfName.FILESPEC.Equals(type)) return null; var ef = PdfReader.GetPdfObject(filespec.Get(PdfName.EF)) as PdfDictionary; if (ef == null) return null; var fn = PdfReader.GetPdfObject(filespec.Get(PdfName.F)) as PdfString; if (fn == null) return null; var prs = PdfReader.GetPdfObject(ef.Get(PdfName.F)) as PRStream; if (prs == null) return null; return new AttachmentFile { Content = PdfReader.GetStreamBytes(prs), FileName = fn.ToUnicodeString() }; }