Mesclar Células Da Tabela

Às vezes, certas linhas de uma tabela requerem um título ou grandes blocos de texto que ocupam toda a largura da tabela. Para o design adequado da tabela, o usuário pode mesclar várias células da tabela em uma. Aspose.Words suporta células mescladas ao trabalhar com todos os formatos de entrada, incluindo a importação de conteúdo HTML.

Como mesclar células da tabela

Em Aspose.Words, as células mescladas são representadas pelas seguintes propriedades da classe CellFormat:

• HorizontalMerge que descreve se a célula faz parte de uma fusão horizontal de células
• VerticalMerge que descreve se a célula faz parte de uma fusão vertical de células

Os valores dessas propriedades determinam o comportamento de mesclagem das células:

• A primeira célula em uma sequência de células mescladas terá CellMerge.First
• Quaisquer células posteriormente mescladas terão CellMerge.Previous
• Uma célula que não é mesclada terá CellMerge.None

Às vezes, ao carregar células de Documento existentes em uma tabela, elas aparecerão mescladas. No entanto, pode realmente ser uma célula longa – às vezes Microsoft Word exporta células mescladas dessa maneira. Isso pode ser confuso ao tentar trabalhar com células individuais, mas não parece haver nenhum padrão específico sobre quando isso acontece.

Verificando se uma célula foi mesclada

Para verificar se uma célula faz parte de uma sequência de células mescladas, basta verificar as propriedades HorizontalMerge e VerticalMerge.

O exemplo de código a seguir mostra como imprimir o tipo de mesclagem de células horizontal e vertical:

// 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 with merged cells.docx");

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

for (Row row : (Iterable<Row>) table.getRows())
{
    for (Cell cell : (Iterable<Cell>) row.getCells())
    {
        System.out.println(printCellMergeType(cell));
    }
}

Mesclar Células Da Tabela Ao Usar DocumentBuilder

Para mesclar células em uma tabela criada com o DocumentBuilder, você precisa definir o tipo de mesclagem apropriado para cada célula em que a mesclagem é esperada – primeiro CellMerge.First e depois CellMerge.Previous.

Além disso, você deve se lembrar de limpar a configuração de mesclagem para as células em que nenhuma mesclagem é necessária – isso pode ser feito definindo a primeira célula sem mesclagem como CellMerge.None. Se isso não for feito, todas as células da tabela serão mescladas.

O exemplo de código a seguir mostra como criar uma tabela com duas linhas onde as células da primeira linha são mescladas horizontalmente:

// 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.insertCell();
builder.getCellFormat().setHorizontalMerge(CellMerge.FIRST);
builder.write("Text in merged cells.");

builder.insertCell();
// This cell is merged to the previous and should be empty.
builder.getCellFormat().setHorizontalMerge(CellMerge.PREVIOUS);
builder.endRow();

builder.insertCell();
builder.getCellFormat().setHorizontalMerge(CellMerge.NONE);
builder.write("Text in one cell.");

builder.insertCell();
builder.write("Text in another cell.");
builder.endRow();
builder.endTable();
        
doc.save(getArtifactsDir() + "WorkingWithTables.HorizontalMerge.docx");

O exemplo de código a seguir mostra como criar uma tabela de duas colunas onde as células da primeira coluna são mescladas verticalmente:

// 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.insertCell();
builder.getCellFormat().setVerticalMerge(CellMerge.FIRST);
builder.write("Text in merged cells.");

builder.insertCell();
builder.getCellFormat().setVerticalMerge(CellMerge.NONE);
builder.write("Text in one cell");
builder.endRow();

builder.insertCell();
// This cell is vertically merged to the cell above and should be empty.
builder.getCellFormat().setVerticalMerge(CellMerge.PREVIOUS);

builder.insertCell();
builder.getCellFormat().setVerticalMerge(CellMerge.NONE);
builder.write("Text in another cell");
builder.endRow();
builder.endTable();
        
doc.save(getArtifactsDir() + "WorkingWithTables.VerticalMerge.docx");

Mesclar células da tabela em outros casos

Em outras situações em que o DocumentBuilder não é usado, como em uma tabela existente, mesclar células da maneira anterior pode não ser tão fácil. Em vez disso, podemos envolver as operações básicas envolvidas na aplicação de propriedades de mesclagem às células em um método que torna a tarefa muito mais fácil. Este método é semelhante ao método de automação de mesclagem, que é chamado para mesclar um intervalo de células em uma tabela.

O código abaixo irá mesclar as células da tabela no intervalo especificado, começando na célula dada e terminando na célula final. Nesse caso, o intervalo pode abranger várias linhas ou colunas:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
void mergeCells(Cell startCell, Cell endCell)
{
    Table parentTable = startCell.getParentRow().getParentTable();

    // Find the row and cell indices for the start and end cell.
    Point startCellPos = new Point(startCell.getParentRow().indexOf(startCell),
        parentTable.indexOf(startCell.getParentRow()));
    Point endCellPos = new Point(endCell.getParentRow().indexOf(endCell), parentTable.indexOf(endCell.getParentRow()));

    // Create a range of cells to be merged based on these indices.
    // Inverse each index if the end cell is before the start cell.
    Rectangle mergeRange = new Rectangle(Math.min(startCellPos.x, endCellPos.y),
        Math.min(startCellPos.y, endCellPos.y),
        Math.abs(endCellPos.x - startCellPos.x) + 1, Math.abs(endCellPos.y - startCellPos.y) + 1);

    for (Row row : parentTable.getRows())
    {
        for (Cell cell : row.getCells())
        {
            Point currentPos = new Point(row.indexOf(cell), parentTable.indexOf(row));

            // Check if the current cell is inside our merge range, then merge it.
            if (mergeRange.contains(currentPos))
            {
                cell.getCellFormat().setHorizontalMerge(currentPos.x == mergeRange.getX() ? CellMerge.FIRST : CellMerge.PREVIOUS);

                cell.getCellFormat().setVerticalMerge(currentPos.y == mergeRange.getY() ? CellMerge.FIRST : CellMerge.PREVIOUS);
            }
        }
    }
}

O exemplo de código a seguir mostra como mesclar um intervalo de células entre duas células especificadas:

// 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 with merged cells.docx");

Table table = doc.getFirstSection().getBody().getTables().get(0);

// We want to merge the range of cells found inbetween these two cells.
Cell cellStartRange = table.getRows().get(0).getCells().get(0);
Cell cellEndRange = table.getRows().get(1).getCells().get(1);

// Merge all the cells between the two specified cells into one.
mergeCells(cellStartRange, cellEndRange);
        
doc.save(getArtifactsDir() + "WorkingWithTables.MergeCellRange.docx");

Células combinadas verticais e horizontais na tabela HTML

Como dissemos em artigos anteriores, uma tabela em Microsoft Word é um conjunto de linhas independentes. Cada linha tem um conjunto de células que são independentes das células de outras linhas. Assim, na tabela Microsoft Word não existe um objeto como uma “coluna”, e" 1a coluna “é algo como"o conjunto das 1AS células de cada linha da tabela”. Isso permite que os usuários tenham uma tabela na qual, por exemplo, a 1a linha consiste em duas células – 2cm e 1cm, e a 2a linha consiste em duas células diferentes – 1cm e 2cm de largura. E Aspose.Words apoia este conceito de tabelas.

Uma tabela em HTML tem uma estrutura essencialmente diferente: cada linha tem o mesmo número de células e (é importante para a tarefa) cada célula tem a largura da coluna correspondente, a mesma para todas as células de uma coluna. Portanto, se HorizontalMerge e VerticalMerge retornarem um valor incorreto, use o seguinte exemplo de código:

// 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 with merged cells.docx");

SpanVisitor visitor = new SpanVisitor(doc);
doc.accept(visitor);

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
/// <summary>
/// Helper class that contains collection of rowinfo for each row.
/// </summary>
public static class TableInfo
{
    public ArrayList<RowInfo> getRows() { return mRows; }

    private ArrayList<RowInfo> mRows = new ArrayList<>();
}

/// <summary>
/// Helper class that contains collection of cellinfo for each cell.
/// </summary>
public static class RowInfo
{
    public ArrayList<CellInfo> getCells() { return mCells; };

    private ArrayList<CellInfo> mCells = new ArrayList<>();
}

/// <summary>
/// Helper class that contains info about cell. currently here is only colspan and rowspan.
/// </summary>
public static class CellInfo
{
    public CellInfo(int colSpan, int rowSpan)
    {
        mColSpan = colSpan;
        mRowSpan = rowSpan;
    }

    public int getColSpan() { return mColSpan; };

    private  int mColSpan;
    public int getRowSpan() { return mRowSpan; };

    private  int mRowSpan;
}

public static class SpanVisitor extends DocumentVisitor
{
    /// <summary>
    /// Creates new SpanVisitor instance.
    /// </summary>
    /// <param name="doc">
    /// Is document which we should parse.
    /// </param>
    public SpanVisitor(Document doc) throws Exception {
        mWordTables = doc.getChildNodes(NodeType.TABLE, true);

        // We will parse HTML to determine the rowspan and colspan of each cell.
        ByteArrayOutputStream htmlStream = new ByteArrayOutputStream();

        HtmlSaveOptions options = new HtmlSaveOptions();
        {
            options.setImagesFolder(System.getProperty("java.io.tmpdir"));
        }

        doc.save(htmlStream, options);

        // Load HTML into the XML document.
        org.jsoup.nodes.Document document = Jsoup.parse(htmlStream.toString());

        // Get collection of tables in the HTML document.
        Elements tables = document.getElementsByTag("table");

        for (Element table : tables) {
            TableInfo tableInf = new TableInfo();

            // Get collection of rows in the table.
            Elements rows = table.getElementsByTag("tr");

            for (Element row : rows) {
                RowInfo rowInf = new RowInfo();

                // Get collection of cells.
                Elements cells = row.getElementsByTag("td");

                for (Element cell : cells) {
                    // Determine row span and colspan of the current cell.
                    String colSpanAttr = cell.attributes().get("colspan");
                    String rowSpanAttr = cell.attributes().get("rowspan");

                    int colSpan = StringUtils.isNotBlank(colSpanAttr) ? Integer.parseInt(colSpanAttr) : 0;
                    int rowSpan = StringUtils.isNotBlank(rowSpanAttr) ? Integer.parseInt(rowSpanAttr) : 0;

                    CellInfo cellInf = new CellInfo(colSpan, rowSpan);
                    rowInf.getCells().add(cellInf);
                }

                tableInf.getRows().add(rowInf);
            }

            mTables.add(tableInf);
        }
    }

    public int visitCellStart(Cell cell)
    {
        int tabIdx = mWordTables.indexOf(cell.getParentRow().getParentTable());
        int rowIdx = cell.getParentRow().getParentTable().indexOf(cell.getParentRow());
        int cellIdx = cell.getParentRow().indexOf(cell);

        int colSpan = 0;
        int rowSpan = 0;
        if (tabIdx < mTables.size() &&
            rowIdx < mTables.get(tabIdx).getRows().size() &&
            cellIdx < mTables.get(tabIdx).getRows().get(rowIdx).getCells().size())
        {
            colSpan = mTables.get(tabIdx).getRows().get(rowIdx).getCells().get(cellIdx).getColSpan();
            rowSpan = mTables.get(tabIdx).getRows().get(rowIdx).getCells().get(cellIdx).getRowSpan();
        }

        System.out.println(MessageFormat.format("{0}.{1}.{2} colspan={3}\t rowspan={4}", tabIdx, rowIdx, cellIdx, colSpan, rowSpan));

        return VisitorAction.CONTINUE;
    }

    private ArrayList<TableInfo> mTables = new ArrayList<>();
    private NodeCollection mWordTables;
}

Converter em células mescladas horizontalmente

Às vezes, não é possível detectar quais células são mescladas porque algumas versões mais recentes de Microsoft Word não usam mais os sinalizadores de mesclagem quando as células são mescladas horizontalmente. Mas para situações em que as células são mescladas em uma célula horizontalmente por sua largura usando sinalizadores de mesclagem, Aspose.Words fornece o método ConvertToHorizontallyMergedCells para converter células. Este método simplesmente transforma a tabela e adiciona novas células conforme necessário.

O exemplo de código a seguir mostra o método acima em operação:

// 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 with merged cells.docx");

Table table = doc.getFirstSection().getBody().getTables().get(0);
// Now merged cells have appropriate merge flags.
table.convertToHorizontallyMergedCells();