SkPDFTagTree Class Reference

#include <SkPDFTag.h>

Classes
class	Mark

Public Member Functions
	SkPDFTagTree ()
	~SkPDFTagTree ()
void	init (SkPDF::StructureElementNode *, SkPDF::Metadata::Outline)
Mark	createMarkIdForNodeId (int nodeId, unsigned pageIndex, SkPoint)
int	createStructParentKeyForNodeId (int nodeId, unsigned pageIndex)
void	addNodeAnnotation (int nodeId, SkPDFIndirectReference annotationRef, unsigned pageIndex)
void	addNodeTitle (int nodeId, SkSpan< const char >)
SkPDFIndirectReference	makeStructTreeRoot (SkPDFDocument *doc)
SkPDFIndirectReference	makeOutline (SkPDFDocument *doc)
SkString	getRootLanguage ()

Detailed Description

Definition at line 20 of file SkPDFTag.h.

Constructor & Destructor Documentation

SkPDFTagTree()

SkPDFTagTree::SkPDFTagTree

(

)

Definition at line 155 of file SkPDFTag.cpp.

: fArena(4 * sizeof(SkPDFTagNode)) {}

~SkPDFTagTree()

SkPDFTagTree::~SkPDFTagTree ( )

default

Member Function Documentation

addNodeAnnotation()

void SkPDFTagTree::addNodeAnnotation	(	int	nodeId,
		SkPDFIndirectReference	annotationRef,
		unsigned	pageIndex
	)

Definition at line 320 of file SkPDFTag.cpp.

                                                                                                         {
    if (!fRoot) {
        return;
    }
    SkPDFTagNode** tagPtr = fNodeMap.find(nodeId);
    if (!tagPtr) {
        return;
    }
    SkPDFTagNode* tag = *tagPtr;
    SkASSERT(tag);
 
    SkPDFTagNode::AnnotationInfo annotationInfo = {pageIndex, annotationRef};
    tag->fAnnotations.push_back(annotationInfo);
}

addNodeTitle()

void SkPDFTagTree::addNodeTitle	(	int	nodeId,
		SkSpan< const char >	title
	)

Definition at line 335 of file SkPDFTag.cpp.

                                                                    {
    if (!fRoot) {
        return;
    }
    SkPDFTagNode** tagPtr = fNodeMap.find(nodeId);
    if (!tagPtr) {
        return;
    }
    SkPDFTagNode* tag = *tagPtr;
    SkASSERT(tag);
 
    if (tag->fWantTitle) {
        tag->fTitle.append(title.data(), title.size());
        // Arbitrary cutoff for size.
        if (tag->fTitle.size() > 1023) {
            tag->fWantTitle = false;
        }
    }
}

createMarkIdForNodeId()

auto SkPDFTagTree::createMarkIdForNodeId	(	int	nodeId,
		unsigned	pageIndex,
		SkPoint	point
	)

Definition at line 209 of file SkPDFTag.cpp.

                                                                                              {
    if (!fRoot) {
        return Mark();
    }
    SkPDFTagNode** tagPtr = fNodeMap.find(nodeId);
    if (!tagPtr) {
        return Mark();
    }
    SkPDFTagNode* tag = *tagPtr;
    SkASSERT(tag);
    while (SkToUInt(fMarksPerPage.size()) < pageIndex + 1) {
        fMarksPerPage.push_back();
    }
    TArray<SkPDFTagNode*>& pageMarks = fMarksPerPage[pageIndex];
    int markId = pageMarks.size();
    tag->fMarkedContent.push_back({{point, pageIndex}, markId});
    pageMarks.push_back(tag);
    return Mark(tag, tag->fMarkedContent.size() - 1);
}

createStructParentKeyForNodeId()

int SkPDFTagTree::createStructParentKeyForNodeId	(	int	nodeId,
		unsigned	pageIndex
	)

Definition at line 229 of file SkPDFTag.cpp.

                                                                               {
    if (!fRoot) {
        return -1;
    }
    SkPDFTagNode** tagPtr = fNodeMap.find(nodeId);
    if (!tagPtr) {
        return -1;
    }
    SkPDFTagNode* tag = *tagPtr;
    SkASSERT(tag);
 
    tag->fCanDiscard = SkPDFTagNode::kNo;
 
    int nextStructParentKey = kFirstAnnotationStructParentKey +
        static_cast<int>(fParentTreeAnnotationNodeIds.size());
    fParentTreeAnnotationNodeIds.push_back(nodeId);
    return nextStructParentKey;
}

getRootLanguage()

SkString SkPDFTagTree::getRootLanguage

(

)

Definition at line 574 of file SkPDFTag.cpp.

                                       {
    return fRoot ? fRoot->fLang : SkString();
}

init()

void SkPDFTagTree::init	(	SkPDF::StructureElementNode *	node,
		SkPDF::Metadata::Outline	outline
	)

Definition at line 193 of file SkPDFTag.cpp.

                                                                                     {
    if (node) {
        fRoot = fArena.make<SkPDFTagNode>();
        fOutline = outline;
        Copy(*node, fRoot, &fArena, &fNodeMap, false);
    }
}

makeOutline()

SkPDFIndirectReference SkPDFTagTree::makeOutline

(

SkPDFDocument *

doc

)

Definition at line 550 of file SkPDFTag.cpp.

                                                                   {
    if (!fRoot || can_discard(fRoot) ||
        fOutline != SkPDF::Metadata::Outline::StructureElementHeaders)
    {
        return SkPDFIndirectReference();
    }
 
    STArray<7, OutlineEntry*> stack;
    OutlineEntry top{{SkString(), Location()}, 0, {}, {}};
    stack.push_back(&top);
    create_outline_from_headers(doc, fRoot, stack);
    if (top.fChildren.empty()) {
        return SkPDFIndirectReference();
    }
    top.emitDescendents(doc);
    SkPDFIndirectReference outlineRef = doc->reserveRef();
    SkPDFDict outline("Outlines");
    outline.insertRef("First", top.fChildren.front().fRef);
    outline.insertRef("Last", top.fChildren.back().fRef);
    outline.insertInt("Count", top.fDescendentsEmitted);
 
    return doc->emit(outline, outlineRef);
}

makeStructTreeRoot()

SkPDFIndirectReference SkPDFTagTree::makeStructTreeRoot

(

SkPDFDocument *

doc

)

Definition at line 355 of file SkPDFTag.cpp.

                                                                          {
    if (!fRoot || can_discard(fRoot)) {
        return SkPDFIndirectReference();
    }
 
    SkPDFIndirectReference ref = doc->reserveRef();
 
    unsigned pageCount = SkToUInt(doc->pageCount());
 
    // Build the StructTreeRoot.
    SkPDFDict structTreeRoot("StructTreeRoot");
    structTreeRoot.insertRef("K", PrepareTagTreeToEmit(ref, fRoot, doc));
    structTreeRoot.insertInt("ParentTreeNextKey", SkToInt(pageCount));
 
    // Build the parent tree, which consists of two things:
    // (1) For each page, a mapping from the marked content IDs on
    // each page to their corresponding tags
    // (2) For each annotation, an indirect reference to that
    // annotation's struct tree element.
    SkPDFDict parentTree("ParentTree");
    auto parentTreeNums = SkPDFMakeArray();
 
    // First, one entry per page.
    SkASSERT(SkToUInt(fMarksPerPage.size()) <= pageCount);
    for (int j = 0; j < fMarksPerPage.size(); ++j) {
        const TArray<SkPDFTagNode*>& pageMarks = fMarksPerPage[j];
        SkPDFArray markToTagArray;
        for (SkPDFTagNode* mark : pageMarks) {
            SkASSERT(mark->fRef);
            markToTagArray.appendRef(mark->fRef);
        }
        parentTreeNums->appendInt(j);
        parentTreeNums->appendRef(doc->emit(markToTagArray));
    }
 
    // Then, one entry per annotation.
    for (size_t j = 0; j < fParentTreeAnnotationNodeIds.size(); ++j) {
        int nodeId = fParentTreeAnnotationNodeIds[j];
        int structParentKey = kFirstAnnotationStructParentKey + static_cast<int>(j);
 
        SkPDFTagNode** tagPtr = fNodeMap.find(nodeId);
        if (!tagPtr) {
            continue;
        }
        SkPDFTagNode* tag = *tagPtr;
        parentTreeNums->appendInt(structParentKey);
        parentTreeNums->appendRef(tag->fRef);
    }
 
    parentTree.insertObject("Nums", std::move(parentTreeNums));
    structTreeRoot.insertRef("ParentTree", doc->emit(parentTree));
 
    // Build the IDTree, a mapping from every unique ID string to
    // a reference to its corresponding structure element node.
    if (!fIdTreeEntries.empty()) {
        std::sort(fIdTreeEntries.begin(), fIdTreeEntries.end(),
                  [](const IDTreeEntry& a, const IDTreeEntry& b) {
                    return a.nodeId < b.nodeId;
                  });
 
        SkPDFDict idTree;
        SkPDFDict idTreeLeaf;
        auto limits = SkPDFMakeArray();
        SkString lowestNodeIdString = SkPDFTagNode::nodeIdToString(
            fIdTreeEntries.begin()->nodeId);
        limits->appendByteString(lowestNodeIdString);
        SkString highestNodeIdString = SkPDFTagNode::nodeIdToString(
            fIdTreeEntries.rbegin()->nodeId);
        limits->appendByteString(highestNodeIdString);
        idTreeLeaf.insertObject("Limits", std::move(limits));
        auto names = SkPDFMakeArray();
        for (const IDTreeEntry& entry : fIdTreeEntries) {
          SkString idString = SkPDFTagNode::nodeIdToString(entry.nodeId);
            names->appendByteString(idString);
            names->appendRef(entry.ref);
        }
        idTreeLeaf.insertObject("Names", std::move(names));
        auto idTreeKids = SkPDFMakeArray();
        idTreeKids->appendRef(doc->emit(idTreeLeaf));
        idTree.insertObject("Kids", std::move(idTreeKids));
        structTreeRoot.insertRef("IDTree", doc->emit(idTree));
    }
 
    return doc->emit(structTreeRoot, ref);
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/pdf/SkPDFTag.h
• third_party/skia/src/pdf/SkPDFTag.cpp