Mesclar células da tabela

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

Como mesclar células de tabela

No 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 mesclagem horizontal de células
  • VerticalMerge que descreve se a célula faz parte de uma mesclagem vertical de células

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

Verifique se a célula está 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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Table with merged cells.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
for row in table.rows:
for cell in row.as_row().cells:
print(self.print_cell_merge_type(cell.as_cell()))

Mesclar células da tabela ao usar o DocumentBuilder

Para mesclar células em uma tabela criada com DocumentBuilder, você precisa definir o tipo de mesclagem apropriado para cada célula onde 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 onde nenhuma mesclagem é necessária – isso pode ser feito definindo a primeira célula sem mesclagem como CellMerge.None. Caso contrário, 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-Python-via-.NET.git.
doc = aw.Document()
builder = aw.DocumentBuilder(doc)
builder.insert_cell()
builder.cell_format.horizontal_merge = aw.tables.CellMerge.FIRST
builder.write("Text in merged cells.")
builder.insert_cell()
# This cell is merged to the previous and should be empty.
builder.cell_format.horizontal_merge = aw.tables.CellMerge.PREVIOUS
builder.end_row()
builder.insert_cell()
builder.cell_format.horizontal_merge = aw.tables.CellMerge.NONE
builder.write("Text in one cell.")
builder.insert_cell()
builder.write("Text in another cell.")
builder.end_row()
builder.end_table()
doc.save(ARTIFACTS_DIR + "WorkingWithTables.horizontal_merge.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-Python-via-.NET.git.
doc = aw.Document()
builder = aw.DocumentBuilder(doc)
builder.insert_cell()
builder.cell_format.vertical_merge = aw.tables.CellMerge.FIRST
builder.write("Text in merged cells.")
builder.insert_cell()
builder.cell_format.vertical_merge = aw.tables.CellMerge.NONE
builder.write("Text in one cell")
builder.end_row()
builder.insert_cell()
# This cell is vertically merged to the cell above and should be empty.
builder.cell_format.vertical_merge = aw.tables.CellMerge.PREVIOUS
builder.insert_cell()
builder.cell_format.vertical_merge = aw.tables.CellMerge.NONE
builder.write("Text in another cell")
builder.end_row()
builder.end_table()
doc.save(ARTIFACTS_DIR + "WorkingWithTables.vertical_merge.docx")

Mesclar células da tabela em outros casos

Em outras situações onde o DocumentBuilder não é utilizado, como em uma tabela existente, mesclar células da forma anterior pode não ser tão fácil. Em vez disso, podemos agrupar 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 Merge, 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 fornecida 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-Python-via-.NET.git.
@staticmethod
def merge_cells(start_cell: aw.tables.Cell, end_cell: aw.tables.Cell):
parent_table = start_cell.parent_row.parent_table
# Find the row and cell indices for the start and end cell.
start_cell_pos = drawing.Point(start_cell.parent_row.index_of(start_cell), parent_table.index_of(start_cell.parent_row))
end_cell_pos = drawing.Point(end_cell.parent_row.index_of(end_cell), parent_table.index_of(end_cell.parent_row))
# Create a range of cells to be merged based on these indices.
# Inverse each index if the end cell is before the start cell.
merge_range = drawing.Rectangle(
min(start_cell_pos.x, end_cell_pos.x),
min(start_cell_pos.y, end_cell_pos.y),
abs(end_cell_pos.x - start_cell_pos.x) + 1,
abs(end_cell_pos.y - start_cell_pos.y) + 1)
for row in parent_table.rows:
row = row.as_row()
for cell in row.cells:
cell = cell.as_cell()
current_pos = drawing.Point(row.index_of(cell), parent_table.index_of(row))
# Check if the current cell is inside our merge range, then merge it.
if merge_range.contains(current_pos):
cell.cell_format.horizontal_merge = aw.tables.CellMerge.FIRST if current_pos.x == merge_range.x else aw.tables.CellMerge.PREVIOUS
cell.cell_format.vertical_merge = aw.tables.CellMerge.FIRST if current_pos.y == merge_range.y else aw.tables.CellMerge.PREVIOUS
view raw merge-cells.py hosted with ❤ by GitHub

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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Table with merged cells.docx")
table = doc.first_section.body.tables[0]
# We want to merge the range of cells found inbetween these two cells.
cell_start_range = table.rows[0].cells[0]
cell_end_range = table.rows[1].cells[1]
# Merge all the cells between the two specified cells into one.
self.merge_cells(cell_start_range, cell_end_range)
doc.save(ARTIFACTS_DIR + "WorkingWithTables.merge_cell_range.docx")

Dependendo da versão do Framework que você está usando, você pode refinar esse método transformando-o em um método de extensão. Nesse caso, você pode chamar esse método diretamente em uma célula para mesclar um intervalo de células, como cell1.Merge(cell2).

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 do 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 horizontalmente em uma célula por sua largura usando sinalizadores de mesclagem, o 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-Python-via-.NET.git.
doc = aw.Document(MY_DIR + "Table with merged cells.docx")
table = doc.first_section.body.tables[0]
# Now merged cells have appropriate merge flags.
table.convert_to_horizontally_merged_cells()