Fusionner les cellules du tableau

Parfois, certaines lignes d’un tableau nécessitent un en-tête ou de gros blocs de texte occupant toute la largeur du tableau. Pour une conception correcte du tableau, l’utilisateur peut fusionner plusieurs cellules du tableau en une seule. Aspose.Words prend en charge les cellules fusionnées lorsque vous travaillez avec tous les formats d’entrée, y compris l’importation de contenu HTML.

Comment fusionner des cellules de tableau

Dans Aspose.Words, les cellules fusionnées sont représentées par les propriétés suivantes de la classe CellFormat:

  • HorizontalMerge qui décrit si la cellule fait partie d’une fusion horizontale de cellules
  • VerticalMerge qui décrit si la cellule fait partie d’une fusion verticale de cellules

Les valeurs de ces propriétés déterminent le comportement de fusion des cellules:

Vérifiez si la cellule est fusionnée

Pour vérifier si une cellule fait partie d’une séquence de cellules fusionnées, on vérifie simplement les propriétés HorizontalMerge et VerticalMerge.

L’exemple de code suivant montre comment imprimer le type de fusion de cellules horizontale et verticale:

# 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()))

Fusionner les cellules du tableau lors de l’utilisation de DocumentBuilder

Pour fusionner des cellules dans un tableau créé avec DocumentBuilder, vous devez définir le type de fusion approprié pour chaque cellule où la fusion est attendue – d’abord CellMerge.First puis CellMerge.Previous.

N’oubliez pas non plus d’effacer le paramètre de fusion pour les cellules pour lesquelles aucune fusion n’est requise – cela peut être fait en définissant la première cellule non fusionnée sur CellMerge.None. Si cela n’est pas fait, toutes les cellules du tableau seront fusionnées.

L’exemple de code suivant montre comment créer un tableau avec deux lignes dans lequel les cellules de la première ligne sont fusionnées horizontalement:

# 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")

L’exemple de code suivant montre comment créer un tableau à deux colonnes dans lequel les cellules de la première colonne sont fusionnées verticalement:

# 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")

Fusionner les cellules du tableau dans d’autres cas

Dans d’autres situations où le DocumentBuilder n’est pas utilisé, comme dans un tableau existant, la fusion de cellules de la manière précédente peut ne pas être aussi simple. Au lieu de cela, nous pouvons regrouper les opérations de base impliquées dans l’application des propriétés de fusion aux cellules dans une méthode qui rend la tâche beaucoup plus facile. Cette méthode est similaire à la méthode d’automatisation Fusion, qui est appelée pour fusionner une plage de cellules dans un tableau.

Le code ci-dessous fusionnera les cellules du tableau dans la plage spécifiée, en commençant à la cellule donnée et en terminant à la cellule de fin. Dans ce cas, la plage peut s’étendre sur plusieurs lignes ou colonnes:

# 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

L’exemple de code suivant montre comment fusionner une plage de cellules entre deux cellules spécifiées:

# 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")

Selon la version du Framework que vous utilisez, vous souhaiterez peut-être affiner cette méthode en la transformant en méthode d’extension. Dans ce cas, vous pouvez appeler cette méthode directement sur une cellule pour fusionner une plage de cellules, comme cell1.Merge(cell2).

Convertir en cellules fusionnées horizontalement

Parfois, il n’est pas possible de détecter quelles cellules sont fusionnées car certaines versions plus récentes de Microsoft Word n’utilisent plus les indicateurs de fusion lorsque les cellules sont fusionnées horizontalement. Mais pour les situations où les cellules sont fusionnées horizontalement en fonction de leur largeur à l’aide d’indicateurs de fusion, Aspose.Words fournit la méthode ConvertToHorizontallyMergedCells pour convertir les cellules. Cette méthode transforme simplement le tableau et ajoute de nouvelles cellules si nécessaire.

L’exemple de code suivant montre la méthode ci-dessus en fonctionnement:

# 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()