Arbeiten mit Abschnitten

Manchmal möchten Sie ein Dokument, das nicht auf allen Seiten die gleiche Formatierung aufweist. Beispielsweise müssen Sie möglicherweise Seitenzahlenformate ändern, eine andere Seitengröße und -ausrichtung haben oder die erste Dokumentseite als Deckblatt ohne Nummerierung verwenden. Das können Sie mit Abschnitten erreichen.

Abschnitte sind Ebenenknoten, die Kopf- und Fußzeilen, Ausrichtung, Spalten, Ränder, Formatierung von Seitenzahlen und andere steuern.

Mit Aspose.Words können Sie Abschnitte verwalten, ein Dokument in Abschnitte unterteilen und Formatierungsänderungen vornehmen, die nur für einen bestimmten Abschnitt gelten. Aspose.Words speichert Informationen zur Abschnittsformatierung wie Kopf- und Fußzeilen, Seiteneinrichtung und Spalteneinstellungen im Abschnittsumbruch.

In diesem Artikel wird erläutert, wie Sie mit Abschnitten und Abschnittsumbrüchen arbeiten.

Was Abschnitt und Abschnittsumbruch ist

Dokumentabschnitte werden durch die Klassen Section und SectionCollection dargestellt. Abschnittsobjekte sind unmittelbare untergeordnete Elemente des Knotens Document und können über die Eigenschaft Sections aufgerufen werden. Sie können diese Knoten mit einigen Methoden verwalten, z Remove, Add, IndexOf, und andere.

Abschnittsumbruch ist eine Option, die Dokumentseiten in Abschnitte mit anpassbaren Layouts unterteilt.

Arten eines Abschnittsumbruchs

Aspose.Words ermöglicht es Ihnen, Dokumente mit verschiedenen Abschnittsumbrüchen der BreakType-Aufzählung zu teilen und zu formatieren:

• SectionBreakContinuous
• SectionBreakNewColumn
• SectionBreakNewPage
• SectionBreakEvenPage
• SectionBreakOddPage

Sie können auch die SectionStart-Aufzählung verwenden, um einen Umbruchstyp auszuwählen, der nur für den ersten Abschnitt gilt, z. B.: NewColumn, NewPage, EvenPage, und OddPage.

Verwalten eines Abschnitts

Da ein Abschnitt ein normaler zusammengesetzter Knoten ist, kann die gesamte Knotenmanipulation API zum Manipulieren von Abschnitten verwendet werden: zum Hinzufügen, Entfernen und anderen Operationen an Abschnitten. Sie können mehr über Knoten im Artikel lesen Aspose.Words Dokumentenobjektmodell (DOM).

Andererseits können Sie auch DocumentBuilder API verwenden, um mit Abschnitten zu arbeiten. In diesem Artikel werden wir uns auf diese spezielle Art der Arbeit mit Abschnitten konzentrieren.

Einfügen oder Entfernen eines Abschnittsumbruchs

Mit Aspose.Words können Sie mit der InsertBreak-Methode einen Abschnittsumbruch in Text einfügen.

Das folgende Codebeispiel zeigt, wie Sie einen Abschnittsumbruch in ein Dokument einfügen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
/// <summary>
/// Insert section breaks before the specified paragraphs.
/// </summary>
private void insertSectionBreaks(ArrayList<Paragraph> topicStartParas)
{
    DocumentBuilder builder = new DocumentBuilder(mDoc);
    for (Paragraph para : topicStartParas)
    {
        Section section = para.getParentSection();

        // Insert section break if the paragraph is not at the beginning of a section already.
        if (para != section.getBody().getFirstParagraph())
        {
            builder.moveTo(para.getFirstChild());
            builder.insertBreak(BreakType.SECTION_BREAK_NEW_PAGE);

            // This is the paragraph that was inserted at the end of the now old section.
            // We don't really need the extra paragraph, we just needed the section.
            section.getBody().getLastParagraph().remove();
        }
    }
}

Verwenden Sie die Methode Remove, um einen Abschnittsumbruch zu löschen. Wenn Sie einen bestimmten Abschnittsumbruch nicht entfernen und stattdessen den Inhalt dieses Abschnitts löschen müssen, können Sie die Methode ClearContent verwenden.

Das folgende Codebeispiel zeigt, wie Abschnittsumbrüche entfernt werden:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
private void removeSectionBreaks(Document doc)
{
    // Loop through all sections starting from the section that precedes the last one and moving to the first section.
    for (int i = doc.getSections().getCount() - 2; i >= 0; i--)
    {
        // Copy the content of the current section to the beginning of the last section.
        doc.getLastSection().prependContent(doc.getSections().get(i));
        // Remove the copied section.
        doc.getSections().get(i).remove();
    }
}

Beachten Sie, dass ein Abschnittsumbruch Informationen über den Abschnitt enthält, der davor steht, nicht über den Abschnitt, der danach folgt. Wenn Sie also einen Abschnittsumbruch entfernen, erhält der Text vor dem entfernten Umbruch die Eigenschaften des darauf folgenden Abschnittsumbruchs. Dies kann dazu führen, dass das gesamte Dokument im Querformat angezeigt wird oder Kopf- und Fußzeilen sich ändern oder vollständig verschwinden.

Einen Abschnitt verschieben

Wenn Sie einen Abschnitt in Ihrem Dokument von einer Position an eine andere verschieben möchten, müssen Sie den Index dieses Abschnitts abrufen. Aspose.Words ermöglicht es Ihnen, eine Schnittposition von a SectionCollection zu erhalten. Sie können die Eigenschaft Sections verwenden, um alle Abschnitte in Ihrem Dokument abzurufen. Wenn Sie jedoch nur den ersten Abschnitt erhalten möchten, können Sie die Eigenschaft FirstSection verwenden.

Das folgende Codebeispiel zeigt, wie auf den ersten Abschnitt zugegriffen und die untergeordneten Elemente eines zusammengesetzten Knotens durchlaufen werden:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

builder.write("Section 1");
builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY);
builder.write("Primary header");
builder.moveToHeaderFooter(HeaderFooterType.FOOTER_PRIMARY);
builder.write("Primary footer");

Section section = doc.getFirstSection();

// A Section is a composite node and can contain child nodes,
// but only if those child nodes are of a "Body" or "HeaderFooter" node type.
for (Node node : section)
{
    switch (node.getNodeType())
    {
        case NodeType.BODY:
        {
            Body body = (Body)node;

            System.out.println("Body:");
            System.out.println(MessageFormat.format("\t\"{0}\"", body.getText().trim()));
            break;
        }
        case NodeType.HEADER_FOOTER:
        {
            HeaderFooter headerFooter = (HeaderFooter)node;

            System.out.println(MessageFormat.format("HeaderFooter type: {0}:", headerFooter.getHeaderFooterType()));
            System.out.println(MessageFormat.format("\t\"{0}\"", headerFooter.getText().trim()));
            break;
        }
        default:
        {
            throw new Exception("Unexpected node type in a section.");
        }
    }
}

Angeben eines Abschnittslayouts

Manchmal möchten Sie, dass Ihr Dokument besser aussieht, indem Sie kreative Layouts für verschiedene Dokumentabschnitte erstellen. Wenn Sie den Typ des aktuellen Schnittrasters angeben möchten, können Sie einen Schnittlayoutmodus mit der SectionLayoutMode-Aufzählung auswählen:

• Standard
• Grid
• LineGrid
• SnapToChars

Das folgende Codebeispiel zeigt, wie Sie die Anzahl der Zeilen begrenzen, die jede Seite haben darf:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

// Enable pitching, and then use it to set the number of lines per page in this section.
// A large enough font size will push some lines down onto the next page to avoid overlapping characters.
builder.getPageSetup().setLayoutMode(SectionLayoutMode.LINE_GRID);
builder.getPageSetup().setLinesPerPage(15);

builder.getParagraphFormat().setSnapToGrid(true);

for (int i = 0; i < 30; i++)
    builder.write("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ");

doc.save(getArtifactsDir() + "WorkingWithDocumentOptionsAndSettings.LinesPerPage.docx");

Einen Abschnitt bearbeiten

Wenn Sie Ihrem Dokument einen neuen Abschnitt hinzufügen, gibt es keinen Text oder Absatz, den Sie bearbeiten können. Mit Aspose.Words können Sie mit der EnsureMinimum –Methode sicherstellen, dass ein Abschnitt einen Text mit mindestens einem Absatz enthält - es wird automatisch ein Textknoten (oder HeaderFooter) zum Dokument hinzugefügt und dann ein Absatz hinzugefügt.

Das folgende Codebeispiel zeigt, wie Sie einen neuen Abschnittsknoten mit EnsureMinimum vorbereiten:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document();

// If we add a new section like this, it will not have a body, or any other child nodes.
doc.getSections().add(new Section(doc));
// Run the "EnsureMinimum" method to add a body and a paragraph to this section to begin editing it.
doc.getLastSection().ensureMinimum();

doc.getSections().get(0).getBody().getFirstParagraph().appendChild(new Run(doc, "Hello world!"));

Inhalt anhängen oder voranstellen

Wenn Sie am Anfang / Ende eines Abschnitts eine Form zeichnen oder Text oder Bild hinzufügen möchten, können Sie die Methoden AppendContent und PrependContent der Klasse Section verwenden.

Das folgende Codebeispiel zeigt, wie Sie den Inhalt eines vorhandenen Abschnitts anhängen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

builder.write("Section 1");
builder.insertBreak(BreakType.SECTION_BREAK_NEW_PAGE);
builder.write("Section 2");
builder.insertBreak(BreakType.SECTION_BREAK_NEW_PAGE);
builder.write("Section 3");

// This is the section that we will append and prepend to.
Section section = doc.getSections().get(2);

// Insert the contents of the first section to the beginning of the third section.
Section sectionToPrepend = doc.getSections().get(0);
section.prependContent(sectionToPrepend);

// Insert the contents of the second section to the end of the third section.
Section sectionToAppend = doc.getSections().get(1);
section.appendContent(sectionToAppend);

Einen Abschnitt klonen

Mit Aspose.Words können Sie einen Abschnitt duplizieren, indem Sie mit der Methode deepClone eine vollständige Kopie davon erstellen.

Das folgende Codebeispiel zeigt, wie Sie den ersten Abschnitt in Ihrem Dokument klonen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Document.docx");
Section cloneSection = doc.getSections().get(0).deepClone();

Abschnitte zwischen Dokumenten kopieren

In einigen Fällen haben Sie möglicherweise große Dokumente mit vielen Abschnitten und möchten den Inhalt eines Abschnitts von einem Dokument in ein anderes kopieren.

Aspose.Words ermöglicht das Kopieren von Abschnitten zwischen Dokumenten mit der ImportNode-Methode.

Das folgende Codebeispiel zeigt, wie Abschnitte zwischen Dokumenten kopiert werden:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document srcDoc = new Document(getMyDir() + "Document.docx");
Document dstDoc = new Document();

Section sourceSection = srcDoc.getSections().get(0);
Section newSection = (Section) dstDoc.importNode(sourceSection, true);
dstDoc.getSections().add(newSection);
        
dstDoc.save(getArtifactsDir() + "WorkingWithSection.CopySection.docx");

Mit Kopf- und Fußzeile des Abschnitts arbeiten

Die Grundregeln für die Anzeige einer Kopf- oder Fußzeile für jeden Abschnitt sind recht einfach:

1. Wenn der Abschnitt keine eigenen Kopf- / Fußzeilen eines bestimmten Typs enthält, wird er aus dem vorherigen Abschnitt übernommen.
2. Die Art der Kopf– / Fußzeile, die auf der Seite angezeigt wird, wird durch die Abschnittseinstellungen “Andere erste Seite” und “Verschiedene ungerade und gerade Seiten” gesteuert - wenn sie deaktiviert sind, werden die eigenen Titel des Abschnitts ignoriert.

Das folgende Codebeispiel zeigt, wie Sie 2 Abschnitte mit unterschiedlichen Überschriften erstellen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

builder.getPageSetup().setDifferentFirstPageHeaderFooter(true);

builder.moveToHeaderFooter(HeaderFooterType.HEADER_FIRST);
builder.getParagraphFormat().setAlignment(ParagraphAlignment.CENTER);
builder.getFont().setName("Arial");
builder.getFont().setBold(true);
builder.getFont().setSize(14);
builder.write("Header for the first page.");

builder.moveToDocumentEnd();
builder.insertBreak(BreakType.SECTION_BREAK_NEW_PAGE);

Section currentSection = builder.getCurrentSection();
PageSetup pageSetup = currentSection.getPageSetup();
pageSetup.setOrientation(Orientation.LANDSCAPE);
// This section does not need a different first-page header/footer we need only one title page in the document,
// and the header/footer for this page has already been defined in the previous section.
pageSetup.setDifferentFirstPageHeaderFooter(false);

// This section displays headers/footers from the previous section
// by default call currentSection.HeadersFooters.LinkToPrevious(false) to cancel this page width
// is different for the new section.
currentSection.getHeadersFooters().linkToPrevious(false);
currentSection.getHeadersFooters().clear();

builder.moveToHeaderFooter(HeaderFooterType.HEADER_PRIMARY);
builder.getParagraphFormat().setAlignment(ParagraphAlignment.CENTER);
builder.getFont().setName("Arial");
builder.getFont().setSize(12);
builder.write("New Header for the first page.");

doc.save(getArtifactsDir() + "WorkingWithHeadersAndFooters.LinkToPreviousHeaderFooter.docx");

Wenn Sie den Text von Kopf- und Fußzeilen entfernen möchten, ohne HeaderFooter -Objekte in Ihrem Dokument zu entfernen, können Sie die ClearHeadersFooters -Methode verwenden. Darüber hinaus können Sie die DeleteHeaderFooterShapes -Methode verwenden, um alle Formen aus Kopf- und Fußzeilen in Ihrem Dokument zu entfernen.

Das folgende Codebeispiel zeigt, wie der Inhalt aller Kopf- und Fußzeilen in einem Abschnitt gelöscht wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Document.docx");
        
Section section = doc.getSections().get(0);
section.clearHeadersFooters();

Das folgende Codebeispiel zeigt, wie Sie alle Formen aus allen Kopfzeilen und Fußzeilen in einem Abschnitt entfernen:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Document.docx");

Section section = doc.getSections().get(0);
section.deleteHeaderFooterShapes();

Seiteneigenschaften in einem Abschnitt anpassen

Bevor Sie eine Seite oder ein Dokument drucken, möchten Sie möglicherweise die Größe und das Layout einer einzelnen Seite oder des gesamten Dokuments anpassen und ändern. Mit der Seiteneinrichtung können Sie die Einstellungen von Dokumentseiten wie Ränder, Ausrichtung und Größe ändern, um verschiedene erste Seiten oder ungerade Seiten zu drucken.

Mit Aspose.Words können Sie Seiten- und Abschnittseigenschaften mithilfe der Klasse PageSetup anpassen.

Das folgende Codebeispiel zeigt, wie Eigenschaften wie Seitengröße und Ausrichtung für den aktuellen Abschnitt festgelegt werden:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

builder.getPageSetup().setOrientation(Orientation.LANDSCAPE);
builder.getPageSetup().setLeftMargin(50.0);
builder.getPageSetup().setPaperSize(PaperSize.PAPER_10_X_14);

doc.save(getArtifactsDir() + "WorkingWithDocumentOptionsAndSettings.SetPageSetupAndSectionFormatting.docx");

Das folgende Codebeispiel zeigt, wie Sie die Seiteneigenschaften in allen Abschnitten ändern:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

builder.writeln("Section 1");
doc.appendChild(new Section(doc));
builder.writeln("Section 2");
doc.appendChild(new Section(doc));
builder.writeln("Section 3");
doc.appendChild(new Section(doc));
builder.writeln("Section 4");

// It is important to understand that a document can contain many sections,
// and each section has its page setup. In this case, we want to modify them all.
for (Section section : doc.getSections())
    section.getPageSetup().setPaperSize(PaperSize.LETTER);

doc.save(getArtifactsDir() + "WorkingWithSection.ModifyPageSetupInAllSections.doc");

Siehe auch

• Logische Ebenen von Knoten in einem Dokument
• Dokumente einfügen und anhängen