DocumentVisitor

DocumentVisitor — Aspose.Note FOSS for Python API Reference

Klasse: DocumentVisitor

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

DocumentVisitor ist die abstrakte Basisklasse für die Traversierung eines OneNote-Dokumentbaums mittels Visitor-Pattern. Erben Sie davon und überschreiben Sie nur die Besuchsmethoden, die Sie benötigen. Aufrufen node.Accept(visitor) um die Traversierung von einem beliebigen Knoten zu starten; aufrufen doc.Accept(visitor) um das gesamte Dokument zu traversieren.

Alle Methoden in der Basisklasse sind No-Ops (geben zurück None). Überschreiben Sie nur die für Ihren Anwendungsfall relevanten.

Visit‑Methoden

Method	Aufgerufen, wenn	Parametertyp
`VisitDocumentStart(document)`	Betritt ein `Document` node	`Document`
`VisitDocumentEnd(document)`	Verlassen eines `Document` node	`Document`
`VisitPageStart(page)`	Betreten eines `Page` node	`Page`
`VisitPageEnd(page)`	Verlassen eines `Page` node	`Page`
`VisitTitleStart(title)`	Betreten eines `Title` node	`Title`
`VisitTitleEnd(title)`	Verlassen eines `Title` node	`Title`
`VisitOutlineStart(outline)`	Betrete ein `Outline` Knoten	`Outline`
`VisitOutlineEnd(outline)`	Verlasse ein `Outline` Knoten	`Outline`
`VisitOutlineElementStart(outline_element)`	Betrete ein `OutlineElement` Knoten	`OutlineElement`
`VisitOutlineElementEnd(outline_element)`	Verlassen eines `OutlineElement` Knoten	`OutlineElement`
`VisitRichTextStart(rich_text)`	Betreten eines `RichText` Knoten	`RichText`
`VisitRichTextEnd(rich_text)`	Verlassen eines `RichText` Knoten	`RichText`
`VisitImageStart(image)`	Betritt ein `Image` Knoten	`Image`
`VisitImageEnd(image)`	Verlässt ein `Image` Knoten	`Image`

Alle Methoden haben die Signatur:

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

Traversierungsreihenfolge

Accept dispatches in einer Tiefen‑Erst‑Vororder‑Durchlauf:

VisitDocumentStart wird beim Betreten des Dokuments aufgerufen.
Jedes Kind Page wird rekursiv besucht (PageStart → children → PageEnd).
Innerhalb eines Page: TitleStart/End, dann jedes Outline (OutlineStart → OutlineElements → OutlineEnd).
Innerhalb eines OutlineElement: OutlineElementStart, dann Kinder (RichText, Image, verschachtelte Elemente), dann OutlineElementEnd.
VisitDocumentEnd wird aufgerufen, nachdem alle Seiten besucht wurden.

Verwendungsbeispiele

Alle Seitentitel sammeln

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)

Knoten nach Typ zählen

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}")

Alle Bilder über den Visitor extrahieren

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)")

Einen Dokumenten‑Gliederungsbericht erstellen

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))

Besuch von einem Unterknoten

Accept kann auf jedem Knoten aufgerufen werden, nicht nur auf dem Root-Dokument:

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())

Unterstützte Knotentypen

Der Visitor dispatcht derzeit für diese Knotentypen: Document, Page, Title, Outline, OutlineElement, RichText, Image. Es gibt keine Besuchsmethoden für Table, TableRow, TableCell, AttachedFile, oder NumberList — diese Knoten werden über GetChildNodes Traversal stattdessen.

Siehe auch

Dokument: Wurzelknoten; Aufruf doc.Accept(visitor) um die vollständige Traversierung zu starten
Seite: VisitPageStart / VisitPageEnd
Gliederung: VisitOutlineStart / VisitOutlineEnd
RichText: VisitRichTextStart / VisitRichTextEnd
Bild: VisitImageStart / VisitImageEnd