Werk met kolommen en rijen

Voor meer controle over hoe tabellen werken, leer hoe kolommen en rijen te manipuleren.

De tabelelementindex zoeken

Kolommen, rijen en cellen worden beheerd door toegang te krijgen tot de geselecteerde documentnode door de index. Het vinden van de index van een knooppunt omvat het verzamelen van alle kindknooppunten van het elementtype uit de oudernode, en vervolgens het gebruik van de IndexOf methode om de index van de gewenste knoop in de collectie te vinden.

Vind de index van een tabel in een document

Soms moet u wijzigingen aanbrengen in een bepaalde tabel in een document. Om dit te doen, kunt u verwijzen naar een tabel door de index.

Het volgende voorbeeld van code laat zien hoe je de index van een tabel in een document kunt ophalen:

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

De index van een rij vinden in een tabel

Ook moet u mogelijk wijzigingen aanbrengen in een specifieke rij in een geselecteerde tabel. Om dit te doen, kunt u ook verwijzen naar een rij door de index.

Het volgende voorbeeld van code laat zien hoe je de index van een rij in een tabel ophaalt:

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

De index van een cel vinden in een rij

Tenslotte moet je misschien wijzigingen aanbrengen in een specifieke cel, en je kunt dit ook doen per celindex.

Het volgende voorbeeld van code laat zien hoe je de index van een cel op een rij ophaalt:

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

Werken met kolommen

In de Aspose.Words Document Object Model (DOM), de Table knooppunt bestaat uit Row nodes en dan Cell knooppunten. In de Document Objectmodel van Aspose.Words, zoals in Word documenten, is er geen concept van een kolom.

Door ontwerp, de tabel rijen in Microsoft Word en Aspose.Words volledig onafhankelijk zijn, en de basiseigenschappen en -bewerkingen zijn alleen in de rijen en cellen van de tabel opgenomen. Dit geeft tabellen de mogelijkheid om een aantal interessante attributen:

• Elke rij kan een totaal ander aantal cellen hebben
• Verticaal kunnen de cellen van elke rij verschillende breedtes hebben
• Het is mogelijk om tabellen samen te voegen met verschillende rijformaten en aantal cellen

Alle bewerkingen uitgevoerd op kolommen zijn eigenlijk “shortcuts” die de operatie uitvoeren door het collectief veranderen van rij cellen op een zodanige manier dat het lijkt alsof ze worden toegepast op kolommen. Dat wil zeggen, je kunt operaties uitvoeren op kolommen door simpelweg te itereren over dezelfde tabel rij cel index.

Het volgende codevoorbeeld vereenvoudigt dergelijke bewerkingen door een gevelklasse te bewijzen die de cellen verzamelt die een “kolom” van een tabel vormen:

// 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;
}

Het volgende voorbeeld van code laat zien hoe je een lege kolom in een tabel invoegt:

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

Het volgende voorbeeld van code laat zien hoe u een kolom uit een tabel in een document verwijdert:

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

Rijen specificeren als koprijen

U kunt ervoor kiezen om de eerste rij in de tabel te herhalen als de Header Row alleen op de eerste pagina of op elke pagina als de tabel is opgesplitst in meerdere. In Aspose.Words, kunt u de Header Row herhalen op elke pagina met behulp van de HeadingFormat eigendom.

U kunt ook meerdere header rijen markeren als dergelijke rijen zich aan het begin van de tabel bevinden. Om dit te doen, moet u de HeadingFormat eigenschappen van deze rijen.

Merk op dat Header Rows niet werken in geneste tabellen. Dat wil zeggen, als je een tafel in een andere tabel hebt, zal deze instelling geen effect hebben. Het is een beperking van Microsoft Word Dat staat dit niet toe, niet Aspose.Words.

Het volgende voorbeeld van code laat zien hoe u een tabel kunt bouwen met Header rijen die zich herhalen op volgende pagina’s:

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

Houd tabellen en rijen te breken over pagina’s

Soms moet de inhoud van een tabel niet over pagina’s worden verdeeld. Bijvoorbeeld, als een titel boven een tabel staat, moeten de titel en de tabel altijd samen op dezelfde pagina worden gehouden om het juiste uiterlijk te behouden.

Er zijn twee aparte technieken die nuttig zijn om deze functionaliteit te bereiken:

• Allow row break across pages, die wordt toegepast op tabelrijen
• Keep with next, die wordt toegepast op de alinea’s in tabelcellen

Standaard zijn bovenstaande eigenschappen uitgeschakeld.

Houd een Row van Breaking Across Pages

Dit houdt in dat de inhoud binnen de cellen van een rij moet worden beperkt van het splitsen over een pagina. In Microsoft Word, Dit kan worden gevonden onder Tabel Eigenschappen als de optie In Aspose.Words Dit wordt gevonden onder de RowFormat object van a Row als eigendom RowFormat.AllowBreakAcrossPages.

Het volgende voorbeeld van code laat zien hoe brekende rijen voor elke rij in een tabel kunnen worden uitgeschakeld:

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

Houd een tafel van Breaking Across Pages

Om te voorkomen dat de tabel over pagina’s verdeeld wordt, moeten we specificeren dat we willen dat de inhoud in de tabel bij elkaar blijft.

Om dit te doen, Aspose.Words maakt gebruik van een methode, die gebruikers in staat stelt een tabel te selecteren en KeepWithNext parameter voor true voor elke alinea binnen de tabelcellen. De uitzondering is de laatste alinea in de tabel, die moet worden vastgesteld op false.

Het volgende voorbeeld van code laat zien hoe u een tabel kunt instellen om samen te blijven op dezelfde pagina:

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