Trabalhar com colunas e linhas

Para obter mais controle sobre como as tabelas funcionam, saiba como manipular colunas e linhas.

Encontre o índice do elemento da tabela

As colunas, linhas e células são geridas acedendo ao nó do documento seleccionado pelo respectivo índice. Encontrar o índice de qualquer nó envolve reunir todos os nós filhos do tipo de elemento do nó pai e, em seguida, usar o método IndexOf para encontrar o índice do nó desejado na coleção.

Encontrar o Índice de uma tabela num documento

Às vezes, pode ser necessário fazer alterações em uma tabela específica em um documento. Para fazer isso, você pode consultar uma tabela por seu índice.

O exemplo de código a seguir mostra como recuperar o índice de uma tabela em um documento:

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

Encontrando o Índice de uma linha em uma tabela

Da mesma forma, pode ser necessário fazer alterações em uma linha específica em uma tabela selecionada. Para fazer isso, você também pode consultar uma linha por seu índice.

O exemplo de código a seguir mostra como recuperar o índice de uma linha em uma tabela:

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

Encontrando o Índice de uma célula em uma linha

Finalmente, você pode precisar fazer alterações em uma célula específica, e você pode fazer isso por índice de célula também.

O exemplo de código a seguir mostra como recuperar o índice de uma célula em uma linha:

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

Trabalhar com colunas

No modelo de objeto de Documento Aspose.Words (DOM), o nó Table consiste em nós Row e depois em nós Cell. Assim, no modelo de objeto Document de Aspose.Words, Como nos documentos do Word, não existe o conceito de coluna.

Por design, as linhas da tabela em Microsoft Word e Aspose.Words são completamente independentes, e as propriedades e Operações básicas estão contidas apenas nas linhas e células da tabela. Isso dá às tabelas a capacidade de ter alguns atributos interessantes:

• Cada linha da tabela pode ter um número completamente diferente de células
• Verticalmente, as células de cada linha podem ter larguras diferentes
• É possível juntar tabelas com diferentes formatos de linha e número de células

Quaisquer operações realizadas em colunas são, na verdade," atalhos " que executam a operação alterando coletivamente as células de linha de forma que pareça que estão sendo aplicadas às colunas. Ou seja, você pode executar operações em colunas simplesmente iterando sobre o mesmo índice de célula da linha da tabela.

O exemplo de código a seguir simplifica essas operações, provando uma classe de fachada que coleta as células que compõem uma" coluna " de uma tabela:

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

O exemplo de código a seguir mostra como inserir uma coluna em branco em uma tabela:

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

O exemplo de código a seguir mostra como remover uma coluna de uma tabela em um documento:

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

Especificar linhas como linhas de cabeçalho

Pode optar por repetir a primeira linha da tabela como linha de cabeçalho apenas na primeira página ou em cada página se a tabela estiver dividida em várias. Em Aspose.Words, você pode repetir a linha do cabeçalho em cada página usando a propriedade HeadingFormat.

Você também pode marcar várias linhas de cabeçalho se essas linhas estiverem localizadas uma após a outra no início da tabela. Para fazer isso, você precisa aplicar as propriedades HeadingFormat a essas linhas.

Observe que as linhas de cabeçalho não funcionam em tabelas aninhadas. Ou seja, se você tiver uma tabela dentro de outra tabela, essa configuração não terá efeito. É uma limitação de Microsoft Word que não permite isso, não Aspose.Words.

O exemplo de código a seguir mostra como construir uma tabela que inclui linhas de cabeçalho que se repetem nas páginas subsequentes:

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

Impedir que tabelas e linhas se separem das páginas

Há momentos em que o conteúdo de uma tabela não deve ser dividido entre páginas. Por exemplo, se um título estiver acima de uma tabela, o Título e a tabela devem ser sempre mantidos juntos na mesma página para preservar a aparência adequada.

Existem duas técnicas separadas que são úteis para alcançar esta funcionalidade:

• Allow row break across pages, que é aplicado às linhas da tabela
• Keep with next, que é aplicado aos parágrafos nas células da tabela

Por padrão, as propriedades acima estão desativadas.

Impedir que uma linha atravesse as páginas

Isso envolve restringir o conteúdo dentro das células de uma linha de ser dividido em uma página. Em Microsoft Word, isso pode ser encontrado em Propriedades da tabela como a opção"Permitir que a linha atravesse as páginas". Em Aspose.Words Isso é encontrado sob o objeto RowFormat de a Row como a propriedade RowFormat.AllowBreakAcrossPages.

O exemplo de código a seguir mostra como desativar a quebra de linhas nas páginas para cada linha em uma tabela:

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

Impedir que uma tabela atravesse páginas

Para impedir que a tabela se divida entre páginas, temos de especificar que queremos que o conteúdo contido na tabela permaneça Unido.

Para fazer isso, Aspose.Words usa um método, que permite aos usuários selecionar uma tabela e habilitar o parâmetro KeepWithNext como true para cada parágrafo dentro das células da tabela. A excepção é o último parágrafo do quadro, que deve ser definido como falso.

O exemplo de código a seguir mostra como definir uma tabela para permanecer juntos na mesma página:

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