Arbeiten mit Spalten und Zeilen

Erfahren Sie, wie Sie Spalten und Zeilen bearbeiten, um mehr Kontrolle über die Funktionsweise von Tabellen zu erhalten.

Suchen Sie den Tabellenelementindex

Spalten, Zeilen und Zellen werden verwaltet, indem auf den ausgewählten Dokumentknoten über seinen Index zugegriffen wird. Das Auffinden des Index eines Knotens umfasst das Sammeln aller untergeordneten Knoten des Elementtyps vom übergeordneten Knoten und das anschließende Verwenden der Methode IndexOf, um den Index des gewünschten Knotens in der Auflistung zu ermitteln.

Suchen Sie den Index einer Tabelle in einem Dokument

Manchmal müssen Sie möglicherweise Änderungen an einer bestimmten Tabelle in einem Dokument vornehmen. Dazu können Sie anhand ihres Index auf eine Tabelle verweisen.

Das folgende Codebeispiel zeigt, wie der Index einer Tabelle in einem Dokument abgerufen wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);

NodeCollection allTables = doc.getChildNodes(NodeType.TABLE, true);
int tableIndex = allTables.indexOf(table);

Suchen des Index einer Zeile in einer Tabelle

Ebenso müssen Sie möglicherweise Änderungen an einer bestimmten Zeile in einer ausgewählten Tabelle vornehmen. Dazu können Sie auch über ihren Index auf eine Zeile verweisen.

Das folgende Codebeispiel zeigt, wie der Index einer Zeile in einer Tabelle abgerufen wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
int rowIndex = table.indexOf(table.getLastRow());

Ermitteln des Index einer Zelle in einer Zeile

Schließlich müssen Sie möglicherweise Änderungen an einer bestimmten Zelle vornehmen, und Sie können dies auch nach Zellindex tun.

Das folgende Codebeispiel zeigt, wie der Index einer Zelle in einer Zeile abgerufen wird:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
int cellIndex = row.indexOf(row.getCells().get(4));

Mit Spalten arbeiten

Im Aspose.Words -Dokumentobjektmodell (DOM) besteht der Table -Knoten aus Row Knoten und dann Cell Knoten. Daher gibt es im Document -Objektmodell von Aspose.Words wie in Word-Dokumenten kein Konzept einer Spalte.

Entwurfsbedingt sind die Tabellenzeilen in Microsoft Word und Aspose.Words völlig unabhängig, und die grundlegenden Eigenschaften und Operationen sind nur in den Zeilen und Zellen der Tabelle enthalten. Dies gibt Tabellen die Möglichkeit, einige interessante Attribute zu haben:

• Jede Tabellenzeile kann eine völlig andere Anzahl von Zellen haben
• Vertikal können die Zellen jeder Zeile unterschiedliche Breiten haben
• Es ist möglich, Tabellen mit unterschiedlichen Zeilenformaten und Zellenzahlen zu verknüpfen

Alle Operationen, die an Spalten ausgeführt werden, sind eigentlich “Verknüpfungen”, die den Vorgang ausführen, indem Zeilenzellen kollektiv so geändert werden, dass es so aussieht, als würden sie auf Spalten angewendet. Das heißt, Sie können Operationen an Spalten ausführen, indem Sie einfach über denselben Tabellenzeilenzellenindex iterieren.

Das folgende Codebeispiel vereinfacht solche Vorgänge, indem es eine Fassadenklasse beweist, die die Zellen sammelt, aus denen eine “Spalte” einer Tabelle besteht:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
/// <summary>
/// Represents a facade object for a column of a table in a Microsoft Word document.
/// </summary>
static class Column
{
    private Column(Table table, int columnIndex) {
        if (table != null) {
            mTable = table;
        } else {
            throw new IllegalArgumentException("table");
        }

        mColumnIndex = columnIndex;
    }

    /// <summary>
    /// Returns a new column facade from the table and supplied zero-based index.
    /// </summary>
    public static Column fromIndex(Table table, int columnIndex)
    {
        return new Column(table, columnIndex);
    }

    private ArrayList<Cell> getCells() {
        return getColumnCells();
    }

    /// <summary>
    /// Returns the index of the given cell in the column.
    /// </summary>
    public int indexOf(Cell cell)
    {
        return getColumnCells().indexOf(cell);
    }

    /// <summary>
    /// Inserts a brand new column before this column into the table.
    /// </summary>
    public Column insertColumnBefore()
    {
        ArrayList<Cell> columnCells = getCells();

        if (columnCells.size() == 0)
            throw new IllegalArgumentException("Column must not be empty");

        // Create a clone of this column.
        for (Cell cell : columnCells)
            cell.getParentRow().insertBefore(cell.deepClone(false), cell);

        // This is the new column.
        Column column = new Column(columnCells.get(0).getParentRow().getParentTable(), mColumnIndex);

        // We want to make sure that the cells are all valid to work with (have at least one paragraph).
        for (Cell cell : column.getCells())
            cell.ensureMinimum();

        // Increase the index which this column represents since there is now one extra column in front.
        mColumnIndex++;

        return column;
    }

    /// <summary>
    /// Removes the column from the table.
    /// </summary>
    public void remove()
    {
        for (Cell cell : getCells())
            cell.remove();
    }

    /// <summary>
    /// Returns the text of the column. 
    /// </summary>
    public String toTxt() throws Exception
    {
        StringBuilder builder = new StringBuilder();

        for (Cell cell : getCells())
            builder.append(cell.toString(SaveFormat.TEXT));

        return builder.toString();
    }

    /// <summary>
    /// Provides an up-to-date collection of cells which make up the column represented by this facade.
    /// </summary>
    private ArrayList<Cell> getColumnCells()
    {
        ArrayList<Cell> columnCells = new ArrayList<Cell>();

        for (Row row : mTable.getRows())
        {
            Cell cell = row.getCells().get(mColumnIndex);
            if (cell != null)
                columnCells.add(cell);
        }

        return columnCells;
    }

    private int mColumnIndex;
    private Table mTable;
}

Das folgende Codebeispiel zeigt, wie Sie eine leere Spalte in eine Tabelle einfügen:

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

Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);

Column column = Column.fromIndex(table, 0);
// Print the plain text of the column to the screen.
System.out.println(column.toTxt());
        
// Create a new column to the left of this column.
// This is the same as using the "Insert Column Before" command in Microsoft Word.
Column newColumn = column.insertColumnBefore();

for (Cell cell : newColumn.getColumnCells())
    cell.getFirstParagraph().appendChild(new Run(doc, "Column Text " + newColumn.indexOf(cell)));

Das folgende Codebeispiel zeigt, wie Sie eine Spalte aus einer Tabelle in einem Dokument 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() + "Tables.docx");

Table table = (Table) doc.getChild(NodeType.TABLE, 1, true);

Column column = Column.fromIndex(table, 2);
column.remove();

Zeilen als Kopfzeilen angeben

Sie können die erste Zeile in der Tabelle als Kopfzeile nur auf der ersten Seite oder auf jeder Seite wiederholen, wenn die Tabelle in mehrere aufgeteilt ist. In Aspose.Words können Sie die Kopfzeile auf jeder Seite mit der Eigenschaft HeadingFormat wiederholen.

Sie können auch mehrere Kopfzeilen markieren, wenn sich solche Zeilen nacheinander am Tabellenanfang befinden. Dazu müssen Sie die HeadingFormat -Eigenschaften auf diese Zeilen anwenden.

Beachten Sie, dass Kopfzeilen in verschachtelten Tabellen nicht funktionieren. Das heißt, wenn Sie eine Tabelle in einer anderen Tabelle haben, hat diese Einstellung keine Auswirkung. Es ist eine Einschränkung von Microsoft Word, die dies nicht zulässt, nicht Aspose.Words.

Das folgende Codebeispiel zeigt, wie Sie eine Tabelle erstellen, die Kopfzeilen enthält, die sich auf nachfolgenden Seiten wiederholen:

// 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.startTable();
builder.getRowFormat().setHeadingFormat(true);
builder.getParagraphFormat().setAlignment(ParagraphAlignment.CENTER);
builder.getCellFormat().setWidth(100.0);
builder.insertCell();
builder.writeln("Heading row 1");
builder.endRow();
builder.insertCell();
builder.writeln("Heading row 2");
builder.endRow();

builder.getCellFormat().setWidth(50.0);
builder.getParagraphFormat().clearFormatting();

for (int i = 0; i < 50; i++)
{
    builder.insertCell();
    builder.getRowFormat().setHeadingFormat(false);
    builder.write("Column 1 Text");
    builder.insertCell();
    builder.write("Column 2 Text");
    builder.endRow();
}

doc.save(getArtifactsDir() + "WorkingWithTables.RepeatRowsOnSubsequentPages.docx");

Verhindern, dass Tabellen und Zeilen über Seiten verteilt werden

Es gibt Zeiten, in denen der Inhalt einer Tabelle nicht auf mehrere Seiten aufgeteilt werden sollte. Wenn sich beispielsweise ein Titel über einer Tabelle befindet, sollten Titel und Tabelle immer auf derselben Seite zusammengehalten werden, um das korrekte Erscheinungsbild zu erhalten.

Es gibt zwei separate Techniken, die nützlich sind, um diese Funktionalität zu erreichen:

• Allow row break across pages, das auf Tabellenzeilen angewendet wird
• Keep with next, das auf Absätze in Tabellenzellen angewendet wird

Standardmäßig sind die obigen Eigenschaften deaktiviert.

Verhindern, dass eine Zeile seitenübergreifend wird

Dies beinhaltet die Einschränkung, dass Inhalte in den Zellen einer Zeile nicht auf eine Seite aufgeteilt werden. In Microsoft Word finden Sie dies unter Tabelleneigenschaften als Option “Zeilenumbruch über Seiten zulassen”. In Aspose.Words findet sich dies unter dem RowFormat -Objekt von a Row als Eigenschaft RowFormat.AllowBreakAcrossPages.

Das folgende Codebeispiel zeigt, wie Sie Zeilenumbrüche über Seiten hinweg für jede Zeile in einer Tabelle deaktivieren:

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

Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);

// Disable breaking across pages for all rows in the table.
for (Row row : (Iterable<Row>) table.getRows())
    row.getRowFormat().setAllowBreakAcrossPages(false);

doc.save(getArtifactsDir() + "WorkingWithTables.RowFormatDisableBreakAcrossPages.docx");

Verhindern, dass eine Tabelle seitenübergreifend wird

Um zu verhindern, dass sich die Tabelle auf mehrere Seiten aufteilt, müssen wir angeben, dass der in der Tabelle enthaltene Inhalt zusammenbleiben soll.

Dazu verwendet Aspose.Words eine Methode, mit der Benutzer eine Tabelle auswählen und den Parameter KeepWithNext für jeden Absatz in den Tabellenzellen auf true setzen können. Die Ausnahme ist der letzte Absatz in der Tabelle, der auf false gesetzt werden sollte.

Das folgende Codebeispiel zeigt, wie Sie eine Tabelle so einrichten, dass sie auf derselben Seite zusammenbleibt:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Table spanning two pages.docx");
        
Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);

// We need to enable KeepWithNext for every paragraph in the table to keep it from breaking across a page,
// except for the last paragraphs in the last row of the table.
for (Cell cell : (Iterable<Cell>) table.getChildNodes(NodeType.CELL, true))
{
    cell.ensureMinimum();

    for (Paragraph para : (Iterable<Paragraph>) cell.getParagraphs())
        if (!(cell.getParentRow().isLastRow() && para.isEndOfCell()))
            para.getParagraphFormat().setKeepWithNext(true);
}

doc.save(getArtifactsDir() + "WorkingWithTables.KeepTableTogether.docx");