public virtual float?GetAttributeAsFloat(String attributeName) { PdfName name = PdfStructTreeRoot.ConvertRoleToPdfName(attributeName); PdfNumber attrVal = GetPdfObject().GetAsNumber(name); return(attrVal != null ? (float?)attrVal.FloatValue() : (float?)null); }
public virtual String GetAttributeAsText(String attributeName) { PdfName name = PdfStructTreeRoot.ConvertRoleToPdfName(attributeName); PdfString attrVal = GetPdfObject().GetAsString(name); return(attrVal != null?attrVal.ToUnicodeString() : null); }
public virtual String GetAttributeAsEnum(String attributeName) { PdfName name = PdfStructTreeRoot.ConvertRoleToPdfName(attributeName); PdfName attrVal = GetPdfObject().GetAsName(name); return(attrVal != null?attrVal.GetValue() : null); }
/// <summary>Init ParentTreeHandler.</summary> /// <remarks>Init ParentTreeHandler. On init the parent tree is read and stored in this instance.</remarks> internal ParentTreeHandler(PdfStructTreeRoot structTreeRoot) { this.structTreeRoot = structTreeRoot; parentTree = new PdfNumTree(structTreeRoot.GetDocument().GetCatalog(), PdfName.ParentTree); RegisterAllMcrs(); pageToStructParentsInd = new Dictionary <PdfIndirectReference, int?>(); }
private static void CopyTo(PdfDocument destDocument, IDictionary<PdfPage, PdfPage> page2page, PdfDocument callingDocument, bool copyFromDestDocument, int insertIndex) { StructureTreeCopier.CopyStructureResult copiedStructure = CopyStructure(destDocument, page2page, callingDocument , copyFromDestDocument); PdfStructTreeRoot destStructTreeRoot = destDocument.GetStructTreeRoot(); destStructTreeRoot.MakeIndirect(destDocument); foreach (PdfDictionary copied in copiedStructure.GetTopsList()) { destStructTreeRoot.AddKidObject(insertIndex, copied); if (insertIndex > -1) { ++insertIndex; } } if (!copyFromDestDocument) { if (!copiedStructure.GetCopiedNamespaces().IsEmpty()) { destStructTreeRoot.GetNamespacesObject().AddAll(copiedStructure.GetCopiedNamespaces()); } PdfDictionary srcRoleMap = callingDocument.GetStructTreeRoot().GetRoleMap(); PdfDictionary destRoleMap = destStructTreeRoot.GetRoleMap(); foreach (KeyValuePair<PdfName, PdfObject> mappingEntry in srcRoleMap.EntrySet()) { if (!destRoleMap.ContainsKey(mappingEntry.Key)) { destRoleMap.Put(mappingEntry.Key, mappingEntry.Value); } else { if (!mappingEntry.Value.Equals(destRoleMap.Get(mappingEntry.Key))) { String srcMapping = mappingEntry.Key + " -> " + mappingEntry.Value; String destMapping = mappingEntry.Key + " -> " + destRoleMap.Get(mappingEntry.Key); ILog logger = LogManager.GetLogger(typeof(StructureTreeCopier)); logger.Warn(String.Format(iText.IO.LogMessageConstant.ROLE_MAPPING_FROM_SOURCE_IS_NOT_COPIED_ALREADY_EXIST , srcMapping, destMapping)); } } } } }
public virtual iText.Kernel.Pdf.Tagging.PdfStructureAttributes RemoveAttribute(String attributeName) { PdfName name = PdfStructTreeRoot.ConvertRoleToPdfName(attributeName); GetPdfObject().Remove(name); SetModified(); return(this); }
public virtual iText.Kernel.Pdf.Tagging.PdfStructureAttributes AddFloatAttribute(String attributeName, float attributeValue) { PdfName name = PdfStructTreeRoot.ConvertRoleToPdfName(attributeName); GetPdfObject().Put(name, new PdfNumber(attributeValue)); SetModified(); return(this); }
public virtual iText.Kernel.Pdf.Tagging.PdfStructureAttributes AddTextAttribute(String attributeName, String attributeValue) { PdfName name = PdfStructTreeRoot.ConvertRoleToPdfName(attributeName); GetPdfObject().Put(name, new PdfString(attributeValue, PdfEncodings.UNICODE_BIG)); SetModified(); return(this); }
/// <summary> /// Adds to the namespace role map (see /// <see cref="SetNamespaceRoleMap(iText.Kernel.Pdf.PdfDictionary)"/> /// ) a single role mapping to the /// default standard structure namespace. /// </summary> /// <param name="thisNsRole"> /// a /// <see cref="System.String"/> /// identifying structure element type in this namespace. /// </param> /// <param name="defaultNsRole"> /// a /// <see cref="System.String"/> /// identifying a structure element type in the default standard structure namespace. /// </param> /// <returns> /// this /// <see cref="PdfNamespace"/> /// instance. /// </returns> public virtual iText.Kernel.Pdf.Tagging.PdfNamespace AddNamespaceRoleMapping(String thisNsRole, String defaultNsRole ) { PdfObject prevVal = GetNamespaceRoleMap(true).Put(PdfStructTreeRoot.ConvertRoleToPdfName(thisNsRole), PdfStructTreeRoot .ConvertRoleToPdfName(defaultNsRole)); LogOverwritingOfMappingIfNeeded(thisNsRole, prevVal); SetModified(); return(this); }
/// <summary> /// Adds to the namespace role map (see /// <see cref="SetNamespaceRoleMap(iText.Kernel.Pdf.PdfDictionary)"/> /// ) a single role mapping to the /// target namespace. /// </summary> /// <param name="thisNsRole"> /// a /// <see cref="System.String"/> /// identifying structure element type in this namespace. /// </param> /// <param name="targetNsRole"> /// a /// <see cref="System.String"/> /// identifying a structure element type in the target namespace. /// </param> /// <param name="targetNs"> /// a /// <see cref="PdfNamespace"/> /// identifying the target namespace. /// </param> /// <returns> /// this /// <see cref="PdfNamespace"/> /// instance. /// </returns> public virtual iText.Kernel.Pdf.Tagging.PdfNamespace AddNamespaceRoleMapping(String thisNsRole, String targetNsRole , iText.Kernel.Pdf.Tagging.PdfNamespace targetNs) { PdfArray targetMapping = new PdfArray(); targetMapping.Add(PdfStructTreeRoot.ConvertRoleToPdfName(targetNsRole)); targetMapping.Add(targetNs.GetPdfObject()); PdfObject prevVal = GetNamespaceRoleMap(true).Put(PdfStructTreeRoot.ConvertRoleToPdfName(thisNsRole), targetMapping ); LogOverwritingOfMappingIfNeeded(thisNsRole, prevVal); SetModified(); return(this); }
private static StructureTreeCopier.CopyStructureResult CopyStructure(PdfDocument destDocument, IDictionary <PdfPage, PdfPage> page2page, PdfDocument callingDocument, bool copyFromDestDocument) { PdfDocument fromDocument = copyFromDestDocument ? destDocument : callingDocument; IDictionary<PdfDictionary, PdfDictionary> topsToFirstDestPage = new Dictionary<PdfDictionary, PdfDictionary >(); ICollection<PdfObject> objectsToCopy = new HashSet<PdfObject>(); IDictionary<PdfDictionary, PdfDictionary> page2pageDictionaries = new Dictionary<PdfDictionary, PdfDictionary >(); foreach (KeyValuePair<PdfPage, PdfPage> page in page2page) { page2pageDictionaries.Put(page.Key.GetPdfObject(), page.Value.GetPdfObject()); ICollection<PdfMcr> mcrs = fromDocument.GetStructTreeRoot().GetPageMarkedContentReferences(page.Key); if (mcrs != null) { foreach (PdfMcr mcr in mcrs) { if (mcr is PdfMcrDictionary || mcr is PdfObjRef) { objectsToCopy.Add(mcr.GetPdfObject()); } PdfDictionary top = AddAllParentsToSet(mcr, objectsToCopy); if (top != null) { if (top.IsFlushed()) { throw new PdfException(PdfException.CannotCopyFlushedTag); } if (!topsToFirstDestPage.ContainsKey(top)) { topsToFirstDestPage.Put(top, page.Value.GetPdfObject()); } } } } } IList<PdfDictionary> topsInOriginalOrder = new List<PdfDictionary>(); foreach (IStructureNode kid in fromDocument.GetStructTreeRoot().GetKids()) { if (kid == null) { continue; } PdfDictionary kidObject = ((PdfStructElem)kid).GetPdfObject(); if (topsToFirstDestPage.ContainsKey(kidObject)) { topsInOriginalOrder.Add(kidObject); } } StructureTreeCopier.StructElemCopyingParams structElemCopyingParams = new StructureTreeCopier.StructElemCopyingParams (objectsToCopy, destDocument, page2pageDictionaries, copyFromDestDocument); PdfStructTreeRoot destStructTreeRoot = destDocument.GetStructTreeRoot(); destStructTreeRoot.MakeIndirect(destDocument); IList<PdfDictionary> copiedTops = new List<PdfDictionary>(); foreach (PdfDictionary top in topsInOriginalOrder) { PdfDictionary copied = CopyObject(top, topsToFirstDestPage.Get(top), false, structElemCopyingParams); copiedTops.Add(copied); } return new StructureTreeCopier.CopyStructureResult(copiedTops, structElemCopyingParams.GetCopiedNamespaces ()); }
/// <returns>parent of the current structure element. Returns null if parent isn't set or if either current element or parent are invalid. /// </returns> public virtual IStructureNode GetParent() { PdfDictionary parent = GetPdfObject().GetAsDictionary(PdfName.P); if (parent == null) { return(null); } if (parent.IsFlushed()) { PdfDocument pdfDoc = GetDocument(); if (pdfDoc == null) { return(null); } PdfStructTreeRoot structTreeRoot = pdfDoc.GetStructTreeRoot(); return(structTreeRoot.GetPdfObject() == parent ? (IStructureNode)structTreeRoot : new iText.Kernel.Pdf.Tagging.PdfStructElem (parent)); } if (IsStructElem(parent)) { return(new iText.Kernel.Pdf.Tagging.PdfStructElem(parent)); } else { PdfDocument pdfDoc = GetDocument(); bool parentIsRoot = pdfDoc != null && PdfName.StructTreeRoot.Equals(parent.GetAsName(PdfName.Type)); parentIsRoot = parentIsRoot || pdfDoc != null && pdfDoc.GetStructTreeRoot().GetPdfObject() == parent; if (parentIsRoot) { return(pdfDoc.GetStructTreeRoot()); } else { return(null); } } }
/// <summary> /// Copies structure to a /// <paramref name="destDocument"/> /// and insert it in a specified position in the document. /// <br/><br/> /// NOTE: Works only for /// <c>PdfStructTreeRoot</c> /// that is read from the document opened in reading mode, /// otherwise an exception is thrown. /// <br/> /// Also, to insert a tagged page into existing tag structure, existing tag structure shouldn't be flushed, otherwise /// an exception may be raised. /// </summary> /// <param name="destDocument">document to copy structure to.</param> /// <param name="insertBeforePage">indicates where the structure to be inserted.</param> /// <param name="page2page">association between original page and copied page.</param> public static void CopyTo(PdfDocument destDocument, int insertBeforePage, IDictionary <PdfPage, PdfPage> page2page , PdfDocument callingDocument) { if (!destDocument.IsTagged()) { return; } // Here we separate the structure tree in two parts: struct elems that belong to the pages which indexes are // less then insertBeforePage and those struct elems that belong to other pages. Some elems might belong // to both parts and actually these are the ones that we are looking for. ICollection <PdfObject> firstPartElems = new HashSet <PdfObject>(); PdfStructTreeRoot destStructTreeRoot = destDocument.GetStructTreeRoot(); for (int i = 1; i < insertBeforePage; ++i) { PdfPage pageOfFirstHalf = destDocument.GetPage(i); ICollection <PdfMcr> pageMcrs = destStructTreeRoot.GetPageMarkedContentReferences(pageOfFirstHalf); if (pageMcrs != null) { foreach (PdfMcr mcr in pageMcrs) { firstPartElems.Add(mcr.GetPdfObject()); PdfDictionary top = AddAllParentsToSet(mcr, firstPartElems); if (top.IsFlushed()) { throw new PdfException(PdfException.TagFromTheExistingTagStructureIsFlushedCannotAddCopiedPageTags); } } } } IList <PdfDictionary> clonedTops = new List <PdfDictionary>(); PdfArray tops = destStructTreeRoot.GetKidsObject(); // Now we "walk" through all the elems which belong to the first part, and look for the ones that contain both // kids from first and second part. We clone found elements and move kids from the second part to cloned elems. int lastTopBefore = 0; for (int i_1 = 0; i_1 < tops.Size(); ++i_1) { PdfDictionary top = tops.GetAsDictionary(i_1); if (firstPartElems.Contains(top)) { lastTopBefore = i_1; StructureTreeCopier.LastClonedAncestor lastCloned = new StructureTreeCopier.LastClonedAncestor(); lastCloned.ancestor = top; PdfDictionary topClone = top.Clone(ignoreKeysForClone); topClone.Put(PdfName.P, destStructTreeRoot.GetPdfObject()); lastCloned.clone = topClone; SeparateKids(top, firstPartElems, lastCloned); if (topClone.ContainsKey(PdfName.K)) { topClone.MakeIndirect(destDocument); clonedTops.Add(topClone); } } } for (int i_2 = 0; i_2 < clonedTops.Count; ++i_2) { destStructTreeRoot.AddKidObject(lastTopBefore + 1 + i_2, clonedTops[i_2]); } CopyTo(destDocument, page2page, callingDocument, false, lastTopBefore + 1); }
/// <summary>Init ParentTreeHandler.</summary> /// <remarks>Init ParentTreeHandler. On init the parent tree is read and stored in this instance.</remarks> internal ParentTreeHandler(PdfStructTreeRoot structTreeRoot) { this.structTreeRoot = structTreeRoot; parentTree = new PdfNumTree(structTreeRoot.GetDocument().GetCatalog(), PdfName.ParentTree); RegisterAllMcrs(); }
public PdfStructureAttributes(String owner) : base(new PdfDictionary()) { GetPdfObject().Put(PdfName.O, PdfStructTreeRoot.ConvertRoleToPdfName(owner)); }