This class allows to compute page numbers of document nodes.

When you create a LayoutCollector and specify a Document document object to attach to, the collector will record mapping of document nodes to layout objects when the document is formatted into pages.

You will be able to find out on which page a particular document node (e.g. run, paragraph or table cell) is located by using the GetStartPageIndex(), GetEndPageIndex() and GetNumPagesSpanned() methods. These methods automatically build page layout model of the document and update fields if required.

When you no longer need to collect layout information, it is best to set the Document property to null to avoid unnecessary collection of more layout mappings.

Examples

Shows how to see the the ranges of pages that a node spans.

auto doc = MakeObject<Document>();
auto layoutCollector = MakeObject<LayoutCollector>(doc);
 
// Call the "GetNumPagesSpanned" method to count how many pages the content of our document spans.
// Since the document is empty, that number of pages is currently zero.
ASPOSE_ASSERT_EQ(doc, layoutCollector->get_Document());
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
// Populate the document with 5 pages of content.
auto builder = MakeObject<DocumentBuilder>(doc);
builder->Write(u"Section 1");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::SectionBreakEvenPage);
builder->Write(u"Section 2");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
 
// Before the layout collector, we need to call the "UpdatePageLayout" method to give us
// an accurate figure for any layout-related metric, such as the page count.
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
layoutCollector->Clear();
doc->UpdatePageLayout();
 
ASSERT_EQ(5, layoutCollector->GetNumPagesSpanned(doc));
 
// We can see the numbers of the start and end pages of any node and their overall page spans.
SharedPtr<NodeCollection> nodes = doc->GetChildNodes(NodeType::Any, true);
for (const auto& node : System::IterateOver(nodes))
{
    std::cout << String::Format(u"->  NodeType.{0}: ", node->get_NodeType()) << std::endl;
    std::cout << (String::Format(u"\tStarts on page {0}, ends on page {1},", layoutCollector->GetStartPageIndex(node),
                                 layoutCollector->GetEndPageIndex(node)) +
                  String::Format(u" spanning {0} pages.", layoutCollector->GetNumPagesSpanned(node)))
              << std::endl;
}
 
// We can iterate over the layout entities using a LayoutEnumerator.
auto layoutEnumerator = MakeObject<LayoutEnumerator>(doc);
 
ASSERT_EQ(LayoutEntityType::Page, layoutEnumerator->get_Type());
 
// The LayoutEnumerator can traverse the collection of layout entities like a tree.
// We can also apply it to any node's corresponding layout entity.
layoutEnumerator->set_Current(layoutCollector->GetEntity(doc->GetChild(NodeType::Paragraph, 1, true)));
 
ASSERT_EQ(LayoutEntityType::Span, layoutEnumerator->get_Type());
ASSERT_EQ(u"¶", layoutEnumerator->get_Text());

#include <Aspose.Words.Cpp/Layout/LayoutCollector.h>

Inheritance diagram for Aspose::Words::Layout::LayoutCollector:

Public Member Functions
	LayoutCollector (SharedPtr< Document > doc)
	Initializes an instance of this class. More...

void	Clear ()
	Clears all collected layout data. Call this method after document was manually updated, or layout was rebuilt. More...

SharedPtr< Document >	get_Document () const
	Gets or sets the document this collector instance is attached to. More...

int32_t	GetEndPageIndex (SharedPtr< Node > node)
	Gets 1-based index of the page where node ends. Returns 0 if node cannot be mapped to a page. More...

SharedPtr< Object >	GetEntity (SharedPtr< Node > node)
	Returns an opaque position of the LayoutEnumerator which corresponds to the specified node. You can use returned value as an argument to Current given the document being enumerated and the document of the node are the same. More...

int32_t	GetNumPagesSpanned (SharedPtr< Node > node)
	Gets number of pages the specified node spans. 0 if node is within a single page. This is the same as GetEndPageIndex() - GetStartPageIndex(). More...

int32_t	GetStartPageIndex (SharedPtr< Node > node)
	Gets 1-based index of the page where node begins. Returns 0 if node cannot be mapped to a page. More...

virtual const TypeInfo &	GetType () const override

virtual bool	Is (const TypeInfo &target) const override

void	set_Document (SharedPtr< Document > value)
	Setter for get_Document. More...

Static Public Member Functions
static const TypeInfo &	Type ()

Constructor & Destructor Documentation

◆ LayoutCollector()

Aspose::Words::Layout::LayoutCollector::LayoutCollector ( System::SharedPtr< Aspose::Words::Document > doc )

Initializes an instance of this class.

Parameters

doc	The document to which this collector instance will be attached to.

Examples

Shows how to see the the ranges of pages that a node spans.

auto doc = MakeObject<Document>();
auto layoutCollector = MakeObject<LayoutCollector>(doc);
 
// Call the "GetNumPagesSpanned" method to count how many pages the content of our document spans.
// Since the document is empty, that number of pages is currently zero.
ASPOSE_ASSERT_EQ(doc, layoutCollector->get_Document());
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
// Populate the document with 5 pages of content.
auto builder = MakeObject<DocumentBuilder>(doc);
builder->Write(u"Section 1");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::SectionBreakEvenPage);
builder->Write(u"Section 2");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
 
// Before the layout collector, we need to call the "UpdatePageLayout" method to give us
// an accurate figure for any layout-related metric, such as the page count.
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
layoutCollector->Clear();
doc->UpdatePageLayout();
 
ASSERT_EQ(5, layoutCollector->GetNumPagesSpanned(doc));
 
// We can see the numbers of the start and end pages of any node and their overall page spans.
SharedPtr<NodeCollection> nodes = doc->GetChildNodes(NodeType::Any, true);
for (const auto& node : System::IterateOver(nodes))
{
    std::cout << String::Format(u"->  NodeType.{0}: ", node->get_NodeType()) << std::endl;
    std::cout << (String::Format(u"\tStarts on page {0}, ends on page {1},", layoutCollector->GetStartPageIndex(node),
                                 layoutCollector->GetEndPageIndex(node)) +
                  String::Format(u" spanning {0} pages.", layoutCollector->GetNumPagesSpanned(node)))
              << std::endl;
}
 
// We can iterate over the layout entities using a LayoutEnumerator.
auto layoutEnumerator = MakeObject<LayoutEnumerator>(doc);
 
ASSERT_EQ(LayoutEntityType::Page, layoutEnumerator->get_Type());
 
// The LayoutEnumerator can traverse the collection of layout entities like a tree.
// We can also apply it to any node's corresponding layout entity.
layoutEnumerator->set_Current(layoutCollector->GetEntity(doc->GetChild(NodeType::Paragraph, 1, true)));
 
ASSERT_EQ(LayoutEntityType::Span, layoutEnumerator->get_Type());
ASSERT_EQ(u"¶", layoutEnumerator->get_Text());

Member Function Documentation

◆ Clear()

void Aspose::Words::Layout::LayoutCollector::Clear ( )

Clears all collected layout data. Call this method after document was manually updated, or layout was rebuilt.

Examples

Shows how to see the the ranges of pages that a node spans.

auto doc = MakeObject<Document>();
auto layoutCollector = MakeObject<LayoutCollector>(doc);
 
// Call the "GetNumPagesSpanned" method to count how many pages the content of our document spans.
// Since the document is empty, that number of pages is currently zero.
ASPOSE_ASSERT_EQ(doc, layoutCollector->get_Document());
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
// Populate the document with 5 pages of content.
auto builder = MakeObject<DocumentBuilder>(doc);
builder->Write(u"Section 1");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::SectionBreakEvenPage);
builder->Write(u"Section 2");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
 
// Before the layout collector, we need to call the "UpdatePageLayout" method to give us
// an accurate figure for any layout-related metric, such as the page count.
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
layoutCollector->Clear();
doc->UpdatePageLayout();
 
ASSERT_EQ(5, layoutCollector->GetNumPagesSpanned(doc));
 
// We can see the numbers of the start and end pages of any node and their overall page spans.
SharedPtr<NodeCollection> nodes = doc->GetChildNodes(NodeType::Any, true);
for (const auto& node : System::IterateOver(nodes))
{
    std::cout << String::Format(u"->  NodeType.{0}: ", node->get_NodeType()) << std::endl;
    std::cout << (String::Format(u"\tStarts on page {0}, ends on page {1},", layoutCollector->GetStartPageIndex(node),
                                 layoutCollector->GetEndPageIndex(node)) +
                  String::Format(u" spanning {0} pages.", layoutCollector->GetNumPagesSpanned(node)))
              << std::endl;
}
 
// We can iterate over the layout entities using a LayoutEnumerator.
auto layoutEnumerator = MakeObject<LayoutEnumerator>(doc);
 
ASSERT_EQ(LayoutEntityType::Page, layoutEnumerator->get_Type());
 
// The LayoutEnumerator can traverse the collection of layout entities like a tree.
// We can also apply it to any node's corresponding layout entity.
layoutEnumerator->set_Current(layoutCollector->GetEntity(doc->GetChild(NodeType::Paragraph, 1, true)));
 
ASSERT_EQ(LayoutEntityType::Span, layoutEnumerator->get_Type());
ASSERT_EQ(u"¶", layoutEnumerator->get_Text());

◆ get_Document()

System::SharedPtr<Aspose::Words::Document> Aspose::Words::Layout::LayoutCollector::get_Document ( ) const

Gets or sets the document this collector instance is attached to.

Examples

Shows how to see the the ranges of pages that a node spans.

auto doc = MakeObject<Document>();
auto layoutCollector = MakeObject<LayoutCollector>(doc);
 
// Call the "GetNumPagesSpanned" method to count how many pages the content of our document spans.
// Since the document is empty, that number of pages is currently zero.
ASPOSE_ASSERT_EQ(doc, layoutCollector->get_Document());
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
// Populate the document with 5 pages of content.
auto builder = MakeObject<DocumentBuilder>(doc);
builder->Write(u"Section 1");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::SectionBreakEvenPage);
builder->Write(u"Section 2");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
 
// Before the layout collector, we need to call the "UpdatePageLayout" method to give us
// an accurate figure for any layout-related metric, such as the page count.
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
layoutCollector->Clear();
doc->UpdatePageLayout();
 
ASSERT_EQ(5, layoutCollector->GetNumPagesSpanned(doc));
 
// We can see the numbers of the start and end pages of any node and their overall page spans.
SharedPtr<NodeCollection> nodes = doc->GetChildNodes(NodeType::Any, true);
for (const auto& node : System::IterateOver(nodes))
{
    std::cout << String::Format(u"->  NodeType.{0}: ", node->get_NodeType()) << std::endl;
    std::cout << (String::Format(u"\tStarts on page {0}, ends on page {1},", layoutCollector->GetStartPageIndex(node),
                                 layoutCollector->GetEndPageIndex(node)) +
                  String::Format(u" spanning {0} pages.", layoutCollector->GetNumPagesSpanned(node)))
              << std::endl;
}
 
// We can iterate over the layout entities using a LayoutEnumerator.
auto layoutEnumerator = MakeObject<LayoutEnumerator>(doc);
 
ASSERT_EQ(LayoutEntityType::Page, layoutEnumerator->get_Type());
 
// The LayoutEnumerator can traverse the collection of layout entities like a tree.
// We can also apply it to any node's corresponding layout entity.
layoutEnumerator->set_Current(layoutCollector->GetEntity(doc->GetChild(NodeType::Paragraph, 1, true)));
 
ASSERT_EQ(LayoutEntityType::Span, layoutEnumerator->get_Type());
ASSERT_EQ(u"¶", layoutEnumerator->get_Text());

◆ GetEndPageIndex()

int32_t Aspose::Words::Layout::LayoutCollector::GetEndPageIndex ( System::SharedPtr< Aspose::Words::Node > node )

Gets 1-based index of the page where node ends. Returns 0 if node cannot be mapped to a page.

Examples

Shows how to see the the ranges of pages that a node spans.

auto doc = MakeObject<Document>();
auto layoutCollector = MakeObject<LayoutCollector>(doc);
 
// Call the "GetNumPagesSpanned" method to count how many pages the content of our document spans.
// Since the document is empty, that number of pages is currently zero.
ASPOSE_ASSERT_EQ(doc, layoutCollector->get_Document());
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
// Populate the document with 5 pages of content.
auto builder = MakeObject<DocumentBuilder>(doc);
builder->Write(u"Section 1");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::SectionBreakEvenPage);
builder->Write(u"Section 2");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
 
// Before the layout collector, we need to call the "UpdatePageLayout" method to give us
// an accurate figure for any layout-related metric, such as the page count.
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
layoutCollector->Clear();
doc->UpdatePageLayout();
 
ASSERT_EQ(5, layoutCollector->GetNumPagesSpanned(doc));
 
// We can see the numbers of the start and end pages of any node and their overall page spans.
SharedPtr<NodeCollection> nodes = doc->GetChildNodes(NodeType::Any, true);
for (const auto& node : System::IterateOver(nodes))
{
    std::cout << String::Format(u"->  NodeType.{0}: ", node->get_NodeType()) << std::endl;
    std::cout << (String::Format(u"\tStarts on page {0}, ends on page {1},", layoutCollector->GetStartPageIndex(node),
                                 layoutCollector->GetEndPageIndex(node)) +
                  String::Format(u" spanning {0} pages.", layoutCollector->GetNumPagesSpanned(node)))
              << std::endl;
}
 
// We can iterate over the layout entities using a LayoutEnumerator.
auto layoutEnumerator = MakeObject<LayoutEnumerator>(doc);
 
ASSERT_EQ(LayoutEntityType::Page, layoutEnumerator->get_Type());
 
// The LayoutEnumerator can traverse the collection of layout entities like a tree.
// We can also apply it to any node's corresponding layout entity.
layoutEnumerator->set_Current(layoutCollector->GetEntity(doc->GetChild(NodeType::Paragraph, 1, true)));
 
ASSERT_EQ(LayoutEntityType::Span, layoutEnumerator->get_Type());
ASSERT_EQ(u"¶", layoutEnumerator->get_Text());

◆ GetEntity()

System::SharedPtr<System::Object> Aspose::Words::Layout::LayoutCollector::GetEntity ( System::SharedPtr< Aspose::Words::Node > node )

Returns an opaque position of the LayoutEnumerator which corresponds to the specified node. You can use returned value as an argument to Current given the document being enumerated and the document of the node are the same.

This method works for only Paragraph nodes, as well as indivisible inline nodes, e.g. BookmarkStart or Shape. It doesn't work for Run, Cell Row or Table nodes, and nodes within header/footer.

Note that the entity returned for a Paragraph node is a paragraph break span. Use the appropriate method to ascend to the parent line

If you need to navigate to a Run of text then you can insert bookmark right before it and then navigate to the bookmark instead.

If you need to navigate to a Cell node then you can move to a Paragraph node in this cell and then ascend to a parent entity. The same approach can be used for Row and Table nodes.

Examples

Shows how to see the the ranges of pages that a node spans.

auto doc = MakeObject<Document>();
auto layoutCollector = MakeObject<LayoutCollector>(doc);
 
// Call the "GetNumPagesSpanned" method to count how many pages the content of our document spans.
// Since the document is empty, that number of pages is currently zero.
ASPOSE_ASSERT_EQ(doc, layoutCollector->get_Document());
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
// Populate the document with 5 pages of content.
auto builder = MakeObject<DocumentBuilder>(doc);
builder->Write(u"Section 1");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::SectionBreakEvenPage);
builder->Write(u"Section 2");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
 
// Before the layout collector, we need to call the "UpdatePageLayout" method to give us
// an accurate figure for any layout-related metric, such as the page count.
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
layoutCollector->Clear();
doc->UpdatePageLayout();
 
ASSERT_EQ(5, layoutCollector->GetNumPagesSpanned(doc));
 
// We can see the numbers of the start and end pages of any node and their overall page spans.
SharedPtr<NodeCollection> nodes = doc->GetChildNodes(NodeType::Any, true);
for (const auto& node : System::IterateOver(nodes))
{
    std::cout << String::Format(u"->  NodeType.{0}: ", node->get_NodeType()) << std::endl;
    std::cout << (String::Format(u"\tStarts on page {0}, ends on page {1},", layoutCollector->GetStartPageIndex(node),
                                 layoutCollector->GetEndPageIndex(node)) +
                  String::Format(u" spanning {0} pages.", layoutCollector->GetNumPagesSpanned(node)))
              << std::endl;
}
 
// We can iterate over the layout entities using a LayoutEnumerator.
auto layoutEnumerator = MakeObject<LayoutEnumerator>(doc);
 
ASSERT_EQ(LayoutEntityType::Page, layoutEnumerator->get_Type());
 
// The LayoutEnumerator can traverse the collection of layout entities like a tree.
// We can also apply it to any node's corresponding layout entity.
layoutEnumerator->set_Current(layoutCollector->GetEntity(doc->GetChild(NodeType::Paragraph, 1, true)));
 
ASSERT_EQ(LayoutEntityType::Span, layoutEnumerator->get_Type());
ASSERT_EQ(u"¶", layoutEnumerator->get_Text());

◆ GetNumPagesSpanned()

int32_t Aspose::Words::Layout::LayoutCollector::GetNumPagesSpanned ( System::SharedPtr< Aspose::Words::Node > node )

Gets number of pages the specified node spans. 0 if node is within a single page. This is the same as GetEndPageIndex() - GetStartPageIndex().

Examples

Shows how to see the the ranges of pages that a node spans.

auto doc = MakeObject<Document>();
auto layoutCollector = MakeObject<LayoutCollector>(doc);
 
// Call the "GetNumPagesSpanned" method to count how many pages the content of our document spans.
// Since the document is empty, that number of pages is currently zero.
ASPOSE_ASSERT_EQ(doc, layoutCollector->get_Document());
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
// Populate the document with 5 pages of content.
auto builder = MakeObject<DocumentBuilder>(doc);
builder->Write(u"Section 1");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::SectionBreakEvenPage);
builder->Write(u"Section 2");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
 
// Before the layout collector, we need to call the "UpdatePageLayout" method to give us
// an accurate figure for any layout-related metric, such as the page count.
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
layoutCollector->Clear();
doc->UpdatePageLayout();
 
ASSERT_EQ(5, layoutCollector->GetNumPagesSpanned(doc));
 
// We can see the numbers of the start and end pages of any node and their overall page spans.
SharedPtr<NodeCollection> nodes = doc->GetChildNodes(NodeType::Any, true);
for (const auto& node : System::IterateOver(nodes))
{
    std::cout << String::Format(u"->  NodeType.{0}: ", node->get_NodeType()) << std::endl;
    std::cout << (String::Format(u"\tStarts on page {0}, ends on page {1},", layoutCollector->GetStartPageIndex(node),
                                 layoutCollector->GetEndPageIndex(node)) +
                  String::Format(u" spanning {0} pages.", layoutCollector->GetNumPagesSpanned(node)))
              << std::endl;
}
 
// We can iterate over the layout entities using a LayoutEnumerator.
auto layoutEnumerator = MakeObject<LayoutEnumerator>(doc);
 
ASSERT_EQ(LayoutEntityType::Page, layoutEnumerator->get_Type());
 
// The LayoutEnumerator can traverse the collection of layout entities like a tree.
// We can also apply it to any node's corresponding layout entity.
layoutEnumerator->set_Current(layoutCollector->GetEntity(doc->GetChild(NodeType::Paragraph, 1, true)));
 
ASSERT_EQ(LayoutEntityType::Span, layoutEnumerator->get_Type());
ASSERT_EQ(u"¶", layoutEnumerator->get_Text());

◆ GetStartPageIndex()

int32_t Aspose::Words::Layout::LayoutCollector::GetStartPageIndex ( System::SharedPtr< Aspose::Words::Node > node )

Gets 1-based index of the page where node begins. Returns 0 if node cannot be mapped to a page.

Examples

Shows how to see the the ranges of pages that a node spans.

auto doc = MakeObject<Document>();
auto layoutCollector = MakeObject<LayoutCollector>(doc);
 
// Call the "GetNumPagesSpanned" method to count how many pages the content of our document spans.
// Since the document is empty, that number of pages is currently zero.
ASPOSE_ASSERT_EQ(doc, layoutCollector->get_Document());
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
// Populate the document with 5 pages of content.
auto builder = MakeObject<DocumentBuilder>(doc);
builder->Write(u"Section 1");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::SectionBreakEvenPage);
builder->Write(u"Section 2");
builder->InsertBreak(BreakType::PageBreak);
builder->InsertBreak(BreakType::PageBreak);
 
// Before the layout collector, we need to call the "UpdatePageLayout" method to give us
// an accurate figure for any layout-related metric, such as the page count.
ASSERT_EQ(0, layoutCollector->GetNumPagesSpanned(doc));
 
layoutCollector->Clear();
doc->UpdatePageLayout();
 
ASSERT_EQ(5, layoutCollector->GetNumPagesSpanned(doc));
 
// We can see the numbers of the start and end pages of any node and their overall page spans.
SharedPtr<NodeCollection> nodes = doc->GetChildNodes(NodeType::Any, true);
for (const auto& node : System::IterateOver(nodes))
{
    std::cout << String::Format(u"->  NodeType.{0}: ", node->get_NodeType()) << std::endl;
    std::cout << (String::Format(u"\tStarts on page {0}, ends on page {1},", layoutCollector->GetStartPageIndex(node),
                                 layoutCollector->GetEndPageIndex(node)) +
                  String::Format(u" spanning {0} pages.", layoutCollector->GetNumPagesSpanned(node)))
              << std::endl;
}
 
// We can iterate over the layout entities using a LayoutEnumerator.
auto layoutEnumerator = MakeObject<LayoutEnumerator>(doc);
 
ASSERT_EQ(LayoutEntityType::Page, layoutEnumerator->get_Type());
 
// The LayoutEnumerator can traverse the collection of layout entities like a tree.
// We can also apply it to any node's corresponding layout entity.
layoutEnumerator->set_Current(layoutCollector->GetEntity(doc->GetChild(NodeType::Paragraph, 1, true)));
 
ASSERT_EQ(LayoutEntityType::Span, layoutEnumerator->get_Type());
ASSERT_EQ(u"¶", layoutEnumerator->get_Text());

◆ GetType()

virtual const System::TypeInfo& Aspose::Words::Layout::LayoutCollector::GetType ( ) const

overridevirtual

Reimplemented from System::Object.

◆ Is()

virtual bool Aspose::Words::Layout::LayoutCollector::Is ( const System::TypeInfo & target ) const

overridevirtual

Reimplemented from System::Object.

◆ set_Document()

void Aspose::Words::Layout::LayoutCollector::set_Document ( System::SharedPtr< Aspose::Words::Document > value )

Setter for Aspose::Words::Layout::LayoutCollector::get_Document.

◆ Type()

static const System::TypeInfo& Aspose::Words::Layout::LayoutCollector::Type ( )

static

Public Member Functions

Static Public Member Functions

Constructor & Destructor Documentation

◆ LayoutCollector()

Member Function Documentation

◆ Clear()

◆ get_Document()

◆ GetEndPageIndex()

◆ GetEntity()

◆ GetNumPagesSpanned()

◆ GetStartPageIndex()

◆ GetType()

◆ Is()

◆ set_Document()

◆ Type()