protected internal TagReference(PdfStructElem referencedTag, TagTreePointer tagPointer, int insertIndex)
{
this.role = referencedTag.GetRole();
this.referencedTag = referencedTag;
this.tagPointer = tagPointer;
this.insertIndex = insertIndex;
}
/// <summary>
/// All tagging logic performed by iText automatically (along with addition of content, annotations etc)
/// uses
/// <see cref="TagTreePointer"/>
/// returned by this method to manipulate the tag structure.
/// </summary>
/// <remarks>
/// All tagging logic performed by iText automatically (along with addition of content, annotations etc)
/// uses
/// <see cref="TagTreePointer"/>
/// returned by this method to manipulate the tag structure.
/// Typically it points at the root tag. This pointer also could be used to tweak auto tagging process
/// (e.g. move this pointer to the Section tag, which would result in placing all automatically tagged content
/// under Section tag).
/// </remarks>
/// <returns>
/// the
/// <c>TagTreePointer</c>
/// which is used for all automatic tagging of the document.
/// </returns>
public virtual TagTreePointer GetAutoTaggingPointer()
{
if (autoTaggingPointer == null)
{
autoTaggingPointer = new TagTreePointer(document);
}
return(autoTaggingPointer);
}
/// <summary>
/// Assigns waiting state to the tag at which given
/// <see cref="TagTreePointer"/>
/// points, associating it with the given
/// <see cref="System.Object"/>
/// . If current tag of the given
/// <see cref="TagTreePointer"/>
/// is already waiting, then after this method call
/// it's associated object will change to the one passed as the argument and the old one will not longer be
/// an associated object.
/// </summary>
/// <param name="pointerToTag">
/// a
/// <see cref="TagTreePointer"/>
/// pointing at a tag which is desired to be marked as waiting.
/// </param>
/// <param name="associatedObj">an object that is to be associated with the waiting tag. A null value is forbidden.
/// </param>
/// <returns>
/// the previous associated object with the tag if it has already had waiting state,
/// or null if it was not waiting tag.
/// </returns>
public virtual Object AssignWaitingState(TagTreePointer pointerToTag, Object associatedObj)
{
if (associatedObj == null)
{
throw new ArgumentException("Passed associated object can not be null.");
}
return(SaveAssociatedObjectForWaitingTag(associatedObj, pointerToTag.GetCurrentStructElem()));
}
private void WrapAllKidsInTag(PdfStructElem parent, PdfName wrapTagRole)
{
int kidsNum = parent.GetKids().Count;
TagTreePointer tagPointer = new TagTreePointer(document);
tagPointer.SetCurrentStructElem(parent).AddTag(0, wrapTagRole);
TagTreePointer newParentOfKids = new TagTreePointer(tagPointer);
tagPointer.MoveToParent();
for (int i = 0; i < kidsNum; ++i)
{
tagPointer.RelocateKid(1, newParentOfKids);
}
}
/// <summary>
/// Moves given
/// <see cref="TagTreePointer"/>
/// to the waiting tag which is associated with the given object.
/// If the passed object is not associated with any waiting tag,
/// <see cref="TagTreePointer"/>
/// position won't change.
/// </summary>
/// <param name="tagPointer">
/// a
/// <see cref="TagTreePointer"/>
/// which position in the tree is to be changed to the
/// waiting tag in case of the successful call.
/// </param>
/// <param name="associatedObject">
/// an object which is associated with the waiting tag to which
/// <see cref="TagTreePointer"/>
/// is to be moved.
/// </param>
/// <returns>
/// true if given object is actually associated with the waiting tag and
/// <see cref="TagTreePointer"/>
/// was moved
/// in order to point at it.
/// </returns>
public virtual bool TryMovePointerToWaitingTag(TagTreePointer tagPointer, Object associatedObject)
{
if (associatedObject == null)
{
return(false);
}
PdfStructElem waitingStructElem = associatedObjToWaitingTag.Get(associatedObject);
if (waitingStructElem != null)
{
tagPointer.SetCurrentStructElem(waitingStructElem);
return(true);
}
return(false);
}
private void WrapAllKidsInTag(PdfStructElem parent, PdfName wrapTagRole, PdfNamespace wrapTagNs)
{
int kidsNum = parent.GetKids().Count;
TagTreePointer tagPointer = new TagTreePointer(parent, document);
tagPointer.AddTag(0, wrapTagRole.GetValue());
if (context.TargetTagStructureVersionIs2())
{
tagPointer.GetProperties().SetNamespace(wrapTagNs);
}
TagTreePointer newParentOfKids = new TagTreePointer(tagPointer);
tagPointer.MoveToParent();
for (int i = 0; i < kidsNum; ++i)
{
tagPointer.RelocateKid(1, newParentOfKids);
}
}
/// <summary>
/// Gets
/// <see cref="iText.Kernel.Pdf.Tagging.PdfStructElem"/>
/// at which
/// <see cref="TagTreePointer"/>
/// points.
/// </summary>
/// <remarks>
/// Gets
/// <see cref="iText.Kernel.Pdf.Tagging.PdfStructElem"/>
/// at which
/// <see cref="TagTreePointer"/>
/// points.
/// <para />
/// NOTE: Be aware that
/// <see cref="iText.Kernel.Pdf.Tagging.PdfStructElem"/>
/// is a low level class, use it carefully,
/// especially in conjunction with high level
/// <see cref="TagTreePointer"/>
/// and
/// <see cref="TagStructureContext"/>
/// classes.
/// </remarks>
/// <param name="pointer">
/// a
/// <see cref="TagTreePointer"/>
/// which points at desired
/// <see cref="iText.Kernel.Pdf.Tagging.PdfStructElem"/>.
/// </param>
/// <returns>
/// a
/// <see cref="iText.Kernel.Pdf.Tagging.PdfStructElem"/>
/// at which given
/// <see cref="TagTreePointer"/>
/// points.
/// </returns>
public virtual PdfStructElem GetPointerStructElem(TagTreePointer pointer)
{
return(pointer.GetCurrentStructElem());
}
internal BackedAccessibilityProperties(TagTreePointer pointerToBackingElem)
{
this.pointerToBackingElem = new TagTreePointer(pointerToBackingElem);
}
public override AccessibilityProperties AddRef(TagTreePointer treePointer)
{
GetBackingElem().AddRef(treePointer.GetCurrentStructElem());
return(this);
}
private void RemoveOldRoot(PdfStructElem oldRoot)
{
TagTreePointer tagPointer = new TagTreePointer(document);
tagPointer.SetCurrentStructElem(oldRoot).RemoveTag();
}
public virtual AccessibilityProperties AddRef(TagTreePointer treePointer)
{
return(this);
}
public override AccessibilityProperties AddRef(TagTreePointer treePointer)
{
refs.Add(new TagTreePointer(treePointer));
return(this);
}
/// <summary>
/// Sets the tag, which is connected with the given accessible element, as a current tag for the given
/// <see cref="TagTreePointer"/>
/// . An exception will be thrown, if given accessible element is not connected to any tag.
/// </summary>
/// <param name="element">an element which has a connection with some tag.</param>
/// <param name="tagPointer">
///
/// <see cref="TagTreePointer"/>
/// which will be moved to the tag connected to the given accessible element.
/// </param>
/// <returns>
/// current
/// <see cref="TagStructureContext"/>
/// instance.
/// </returns>
public virtual iText.Kernel.Pdf.Tagutils.TagStructureContext MoveTagPointerToTag(IAccessibleElement element
, TagTreePointer tagPointer)
{
PdfStructElem connectedStructElem = connectedModelToStruct.Get(element);
if (connectedStructElem == null)
{
throw new PdfException(PdfException.GivenAccessibleElementIsNotConnectedToAnyTag);
}
tagPointer.SetCurrentStructElem(connectedStructElem);
return(this);
}