DocumentVisitor

DocumentVisitor — Aspose.Note FOSS for Python API Reference

Class: DocumentVisitor

Package: aspose.note Import: from aspose.note import DocumentVisitor

DocumentVisitor is the abstract base class for visitor-pattern traversal of a OneNote document tree. Subclass it and override only the visit methods you need. Call node.Accept(visitor) to start traversal from any node; call doc.Accept(visitor) to traverse the entire document.

All methods in the base class are no-ops (return None). Override only the ones relevant to your use case.

Visit Methods

Method	Called when	Parameter type
`VisitDocumentStart(document)`	Entering a `Document` node	`Document`
`VisitDocumentEnd(document)`	Leaving a `Document` node	`Document`
`VisitPageStart(page)`	Entering a `Page` node	`Page`
`VisitPageEnd(page)`	Leaving a `Page` node	`Page`
`VisitTitleStart(title)`	Entering a `Title` node	`Title`
`VisitTitleEnd(title)`	Leaving a `Title` node	`Title`
`VisitOutlineStart(outline)`	Entering an `Outline` node	`Outline`
`VisitOutlineEnd(outline)`	Leaving an `Outline` node	`Outline`
`VisitOutlineElementStart(outline_element)`	Entering an `OutlineElement` node	`OutlineElement`
`VisitOutlineElementEnd(outline_element)`	Leaving an `OutlineElement` node	`OutlineElement`
`VisitRichTextStart(rich_text)`	Entering a `RichText` node	`RichText`
`VisitRichTextEnd(rich_text)`	Leaving a `RichText` node	`RichText`
`VisitImageStart(image)`	Entering an `Image` node	`Image`
`VisitImageEnd(image)`	Leaving an `Image` node	`Image`

All methods have the signature:

def VisitXxxStart(self, node: NodeType) -> None: ...
def VisitXxxEnd(self, node: NodeType) -> None: ...

Traversal Order

Accept dispatches in a depth-first, pre-order traversal:

VisitDocumentStart is called on entering the document.
Each child Page is visited recursively (PageStart → children → PageEnd).
Within a Page: TitleStart/End, then each Outline (OutlineStart → OutlineElements → OutlineEnd).
Within an OutlineElement: OutlineElementStart, then children (RichText, Image, nested elements), then OutlineElementEnd.
VisitDocumentEnd is called after all pages have been visited.

Usage Examples

Collect all page titles

from aspose.note import Document, DocumentVisitor, Page, Title

class TitleCollector(DocumentVisitor):
    def __init__(self):
        self.titles = []

    def VisitTitleStart(self, title: Title) -> None:
        if title.TitleText:
            self.titles.append(title.TitleText.Text)

doc = Document("MyNotes.one")
visitor = TitleCollector()
doc.Accept(visitor)
print(visitor.titles)

Count nodes by type

from aspose.note import Document, DocumentVisitor, Page, RichText, Image

class NodeCounter(DocumentVisitor):
    def __init__(self):
        self.pages = 0
        self.rich_texts = 0
        self.images = 0

    def VisitPageStart(self, page: Page) -> None:
        self.pages += 1

    def VisitRichTextStart(self, rich_text: RichText) -> None:
        self.rich_texts += 1

    def VisitImageStart(self, image: Image) -> None:
        self.images += 1

doc = Document("MyNotes.one")
counter = NodeCounter()
doc.Accept(counter)
print(f"Pages: {counter.pages}, RichText: {counter.rich_texts}, Images: {counter.images}")

Extract all images via visitor

from aspose.note import Document, DocumentVisitor, Image

class ImageExtractor(DocumentVisitor):
    def __init__(self):
        self.images = []

    def VisitImageStart(self, image: Image) -> None:
        if image.Bytes:
            self.images.append(image)

doc = Document("MyNotes.one")
extractor = ImageExtractor()
doc.Accept(extractor)

for i, img in enumerate(extractor.images):
    filename = img.FileName or f"image_{i}.bin"
    with open(filename, "wb") as f:
        f.write(img.Bytes)
    print(f"Saved: {filename} ({len(img.Bytes)} bytes)")

Build a document outline report

from aspose.note import (
    Document, DocumentVisitor,
    Page, Outline, OutlineElement, RichText
)

class OutlineReporter(DocumentVisitor):
    def __init__(self):
        self._indent = 0
        self.lines = []

    def VisitPageStart(self, page: Page) -> None:
        title = page.Title.TitleText.Text if page.Title and page.Title.TitleText else "(untitled)"
        self.lines.append(f"PAGE: {title}")
        self._indent = 1

    def VisitOutlineElementStart(self, elem: OutlineElement) -> None:
        self._indent = 2 + elem.IndentLevel

    def VisitRichTextStart(self, rt: RichText) -> None:
        if rt.Text.strip():
            self.lines.append("  " * self._indent + rt.Text.strip())

doc = Document("MyNotes.one")
reporter = OutlineReporter()
doc.Accept(reporter)
print("\n".join(reporter.lines))

Visit from a sub-node

Accept can be called on any node, not just the root document:

from aspose.note import Document, Page, DocumentVisitor, RichText

class TextPrinter(DocumentVisitor):
    def VisitRichTextStart(self, rt: RichText) -> None:
        print(rt.Text)

doc = Document("MyNotes.one")
pages = doc.GetChildNodes(Page)
if pages:
    # Visit only the first page
    pages[0].Accept(TextPrinter())

Supported Node Types

The visitor currently dispatches for these node types: Document, Page, Title, Outline, OutlineElement, RichText, Image. There are no visit methods for Table, TableRow, TableCell, AttachedFile, or NumberList — those nodes are reached via GetChildNodes traversal instead.