/// <summary>Removes the current tag.</summary> /// <remarks> /// Removes the current tag. If it has kids, they will become kids of the current tag parent. /// This method call moves this /// <c>TagTreePointer</c> /// to the current tag parent. /// <br/><br/> /// You cannot remove root tag, and also you cannot remove any tag if document's tag structure was partially flushed; /// in this two cases an exception will be thrown. /// </remarks> /// <returns> /// this /// <see cref="TagStructureContext"/> /// instance. /// </returns> public virtual iText.Kernel.Pdf.Tagutils.TagTreePointer RemoveTag() { IPdfStructElem parentElem = GetCurrentStructElem().GetParent(); if (parentElem is PdfStructTreeRoot) { throw new PdfException(PdfException.CannotRemoveDocumentRootTag); } IList <IPdfStructElem> kids = GetCurrentStructElem().GetKids(); PdfStructElem parent = (PdfStructElem)parentElem; if (parent.IsFlushed()) { throw new PdfException(PdfException.CannotRemoveTagBecauseItsParentIsFlushed); } int removedKidIndex = parent.RemoveKid(GetCurrentStructElem()); GetCurrentStructElem().GetPdfObject().GetIndirectReference().SetFree(); foreach (IPdfStructElem kid in kids) { if (kid is PdfStructElem) { parent.AddKid(removedKidIndex++, (PdfStructElem)kid); } else { PdfMcr mcr = PrepareMcrForMovingToNewParent((PdfMcr)kid, parent); parent.AddKid(removedKidIndex++, mcr); } } SetCurrentStructElem(parent); return(this); }
public virtual IPdfStructElem RemoveKid(int index) { PdfObject k = GetK(); if (k == null || !k.IsArray() && index != 0) { throw new IndexOutOfRangeException(); } if (k.IsArray()) { PdfArray kidsArray = (PdfArray)k; k = kidsArray.Get(index); kidsArray.Remove(index); if (kidsArray.IsEmpty()) { GetPdfObject().Remove(PdfName.K); } } else { GetPdfObject().Remove(PdfName.K); } IPdfStructElem removedKid = ConvertPdfObjectToIPdfStructElem(k); if (removedKid is PdfMcr) { GetDocument().GetStructTreeRoot().GetParentTreeHandler().UnregisterMcr((PdfMcr)removedKid); } return(removedKid); }
private void RemovePageTagFromParent(IPdfStructElem pageTag, IPdfStructElem parent) { if (parent is PdfStructElem) { PdfStructElem structParent = (PdfStructElem)parent; if (!structParent.IsFlushed()) { structParent.RemoveKid(pageTag); PdfDictionary parentObject = structParent.GetPdfObject(); if (!connectedStructToModel.ContainsKey(parentObject) && parent.GetKids().Count == 0 && parentObject != rootTagElement .GetPdfObject()) { RemovePageTagFromParent(structParent, parent.GetParent()); parentObject.GetIndirectReference().SetFree(); } } else { if (pageTag is PdfMcr) { throw new PdfException(PdfException.CannotRemoveTagBecauseItsParentIsFlushed); } } } }
private void FlushAllKids(IPdfStructElem elem) { foreach (IPdfStructElem kid in elem.GetKids()) { if (kid is PdfStructElem) { FlushAllKids(kid); ((PdfStructElem)kid).Flush(); } } }
/// <returns>parent of the flushed tag</returns> internal virtual IPdfStructElem FlushTag(PdfStructElem tagStruct) { IAccessibleElement modelElement = connectedStructToModel.JRemove(tagStruct.GetPdfObject()); if (modelElement != null) { connectedModelToStruct.JRemove(modelElement); } IPdfStructElem parent = tagStruct.GetParent(); FlushStructElementAndItKids(tagStruct); return(parent); }
public virtual int RemoveKid(IPdfStructElem kid) { if (kid is PdfMcr) { PdfMcr mcr = (PdfMcr)kid; GetDocument().GetStructTreeRoot().GetParentTreeHandler().UnregisterMcr(mcr); return(RemoveKidObject(mcr.GetPdfObject())); } else { if (kid is iText.Kernel.Pdf.Tagging.PdfStructElem) { return(RemoveKidObject(((iText.Kernel.Pdf.Tagging.PdfStructElem)kid).GetPdfObject())); } } return(-1); }
private IPdfStructElem ConvertPdfObjectToIPdfStructElem(PdfObject obj) { if (obj.IsIndirectReference()) { obj = ((PdfIndirectReference)obj).GetRefersTo(); } IPdfStructElem elem = null; switch (obj.GetObjectType()) { case PdfObject.DICTIONARY: { PdfDictionary d = (PdfDictionary)obj; if (IsStructElem(d)) { elem = new iText.Kernel.Pdf.Tagging.PdfStructElem(d); } else { if (PdfName.MCR.Equals(d.GetAsName(PdfName.Type))) { elem = new PdfMcrDictionary(d, this); } else { if (PdfName.OBJR.Equals(d.GetAsName(PdfName.Type))) { elem = new PdfObjRef(d, this); } } } break; } case PdfObject.NUMBER: { elem = new PdfMcrNumber((PdfNumber)obj, this); break; } default: { break; } } return(elem); }
// it is StructTreeRoot // should never happen as we always should have only one root tag and we don't remove it private void FlushParentIfBelongsToPage(PdfStructElem parent, PdfPage currentPage) { if (parent.IsFlushed() || connectedStructToModel.ContainsKey(parent.GetPdfObject()) || parent.GetPdfObject () == rootTagElement.GetPdfObject()) { return; } IList <IPdfStructElem> kids = parent.GetKids(); bool allKidsBelongToPage = true; foreach (IPdfStructElem kid in kids) { if (kid is PdfMcr) { PdfDictionary kidPage = ((PdfMcr)kid).GetPageObject(); if (!kidPage.IsFlushed() && !kidPage.Equals(currentPage.GetPdfObject())) { allKidsBelongToPage = false; break; } } else { if (kid is PdfStructElem) { // If kid is structElem and was already flushed then in kids list there will be null for it instead of // PdfStructElem. And therefore if we get into this if clause it means that some StructElem wasn't flushed. allKidsBelongToPage = false; break; } } } if (allKidsBelongToPage) { IPdfStructElem parentsParent = parent.GetParent(); parent.Flush(); if (parentsParent is PdfStructElem) { FlushParentIfBelongsToPage((PdfStructElem)parentsParent, currentPage); } } return; }
/// <summary>Flushes the current tag and all it's descenders.</summary> /// <remarks> /// Flushes the current tag and all it's descenders. /// This method call moves this /// <c>TagTreePointer</c> /// to the current tag parent. /// <p> /// <br /><br /> /// If some of the tags to be flushed are still connected to the accessible elements, then these tags are considered /// as not yet finished ones, and they won't be flushed immediately, but they will be flushed, when the connection /// is removed. /// </remarks> /// <returns> /// this /// <see cref="TagStructureContext"/> /// instance. /// </returns> public virtual iText.Kernel.Pdf.Tagutils.TagTreePointer FlushTag() { if (GetCurrentStructElem().GetPdfObject() == tagStructureContext.GetRootTag().GetPdfObject()) { throw new PdfException(PdfException.CannotFlushDocumentRootTagBeforeDocumentIsClosed); } IPdfStructElem parent = tagStructureContext.FlushTag(GetCurrentStructElem()); if (parent != null) { // parent is not flushed SetCurrentStructElem((PdfStructElem)parent); } else { SetCurrentStructElem(tagStructureContext.GetRootTag()); } return(this); }
/// <summary> /// Moves this /// <c>TagTreePointer</c> /// instance to the parent of the current tag. /// </summary> /// <returns> /// this /// <see cref="TagStructureContext"/> /// instance. /// </returns> public virtual iText.Kernel.Pdf.Tagutils.TagTreePointer MoveToParent() { if (GetCurrentStructElem().GetPdfObject() == tagStructureContext.GetRootTag().GetPdfObject()) { throw new PdfException(PdfException.CannotMoveToParentCurrentElementIsRoot); } IPdfStructElem parent = GetCurrentStructElem().GetParent(); if (parent == null) { //TODO log that parent is flushed MoveToRoot(); } else { SetCurrentStructElem((PdfStructElem)parent); } return(this); }
protected internal virtual void InspectKid(IPdfStructElem kid) { try { if (kid is PdfStructElem) { PdfStructElem structElemKid = (PdfStructElem)kid; PdfName s = structElemKid.GetRole(); String tagN = s.GetValue(); String tag = FixTagName(tagN); @out.Write("<"); @out.Write(tag); InspectAttributes(structElemKid); @out.Write(">" + Environment.NewLine); PdfString alt = (structElemKid).GetAlt(); if (alt != null) { @out.Write("<alt><![CDATA["); @out.Write(iText.IO.Util.StringUtil.ReplaceAll(alt.GetValue(), "[\\000]*", "")); @out.Write("]]></alt>" + Environment.NewLine); } InspectKids(structElemKid.GetKids()); @out.Write("</"); @out.Write(tag); @out.Write(">" + Environment.NewLine); } else { if (kid is PdfMcr) { ParseTag((PdfMcr)kid); } else { @out.Write(" <flushedKid/> "); } } } catch (System.IO.IOException e) { throw new iText.IO.IOException(iText.IO.IOException.UnknownIOException, e); } }
/// <summary> /// Moves this /// <c>TagTreePointer</c> /// instance to the kid of the current tag. /// </summary> /// <param name="kidIndex">zero-based index of the current tag kid to which pointer will be moved.</param> /// <returns> /// this /// <see cref="TagStructureContext"/> /// instance. /// </returns> public virtual iText.Kernel.Pdf.Tagutils.TagTreePointer MoveToKid(int kidIndex) { IPdfStructElem kid = GetCurrentStructElem().GetKids()[kidIndex]; if (kid is PdfStructElem) { SetCurrentStructElem((PdfStructElem)kid); } else { if (kid is PdfMcr) { throw new PdfException(PdfException.CannotMoveToMarkedContentReference); } else { throw new PdfException(PdfException.CannotMoveToFlushedKid); } } return(this); }
/// <summary> /// Moves kid of the current tag to the tag at which given /// <c>TagTreePointer</c> /// points. /// This method doesn't change pointerToNewParent position. /// </summary> /// <param name="kidIndex">zero-based index of the current tag's kid to be relocated.</param> /// <param name="pointerToNewParent"> /// the /// <c>TagTreePointer</c> /// which is positioned at the tag which will become kid's new parent. /// </param> /// <returns> /// this /// <see cref="TagStructureContext"/> /// instance. /// </returns> public virtual iText.Kernel.Pdf.Tagutils.TagTreePointer RelocateKid(int kidIndex, iText.Kernel.Pdf.Tagutils.TagTreePointer pointerToNewParent) { if (GetDocument() != pointerToNewParent.GetDocument()) { throw new PdfException(PdfException.TagCannotBeMovedToTheAnotherDocumentsTagStructure); } IPdfStructElem removedKid = GetCurrentStructElem().RemoveKid(kidIndex); if (removedKid is PdfStructElem) { pointerToNewParent.AddNewKid((PdfStructElem)removedKid); } else { if (removedKid is PdfMcr) { PdfMcr mcrKid = PrepareMcrForMovingToNewParent((PdfMcr)removedKid, pointerToNewParent.GetCurrentStructElem ()); pointerToNewParent.AddNewKid(mcrKid); } } return(this); }