Scal komórki tabeli

Czasami niektóre wiersze tabeli wymagają nagłówka lub dużych bloków tekstu zajmujących całą szerokość tabeli. Dla prawidłowego zaprojektowania tabeli użytkownik może połączyć kilka komórek tabeli w jedną. Aspose.Words obsługuje scalone komórki podczas pracy ze wszystkimi formatami wejściowymi, w tym podczas importowania treści HTML.

Jak scalić komórki tabeli

W Aspose.Words połączone komórki są reprezentowane przez następujące właściwości klasy CellFormat:

  • HorizontalMerge, który opisuje, czy komórka jest częścią poziomego scalania komórek
  • VerticalMerge, który opisuje, czy komórka jest częścią pionowego scalania komórek

Wartości tych właściwości określają zachowanie komórek podczas scalania:

Sprawdź, czy komórka jest scalona

Aby sprawdzić, czy komórka jest częścią sekwencji połączonych komórek, po prostu sprawdzamy właściwości HorizontalMerge i VerticalMerge.

Poniższy przykład kodu pokazuje, jak wydrukować typ scalania komórek w poziomie i pionie:

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

Scal komórki tabeli podczas korzystania z narzędzia DocumentBuilder

Aby scalić komórki w tabeli utworzonej za pomocą DocumentBuilder, należy ustawić odpowiedni typ scalania dla każdej komórki, w której ma nastąpić scalanie – najpierw CellMerge.First, a następnie CellMerge.Previous.

Należy także pamiętać o wyczyszczeniu ustawienia scalania dla tych komórek, które nie wymagają scalania – można to zrobić, ustawiając pierwszą komórkę niescaloną na CellMerge.None. Jeśli nie zostanie to zrobione, wszystkie komórki w tabeli zostaną scalone.

Poniższy przykład kodu pokazuje, jak utworzyć tabelę z dwoma wierszami, w której komórki pierwszego wiersza są scalone w poziomie:

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

Poniższy przykład kodu pokazuje, jak utworzyć dwukolumnową tabelę, w której komórki w pierwszej kolumnie są scalone w pionie:

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

Scal komórki tabeli w innych przypadkach

W innych sytuacjach, w których nie jest używany DocumentBuilder, na przykład w istniejącej tabeli, łączenie komórek w poprzedni sposób może nie być takie proste. Zamiast tego możemy opakować podstawowe operacje związane z zastosowaniem właściwości scalania do komórek w metodę, która znacznie ułatwia to zadanie. Ta metoda jest podobna do metody automatyzacji scalania, która jest wywoływana w celu scalania zakresu komórek w tabeli.

Poniższy kod połączy komórki tabeli w określonym zakresie, zaczynając od podanej komórki i kończąc na komórce końcowej. W takim przypadku zakres może obejmować wiele wierszy lub kolumn:

# 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

Poniższy przykład kodu pokazuje, jak scalić zakres komórek między dwiema określonymi komórkami:

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

W zależności od używanej wersji Framework, możesz chcieć udoskonalić tę metodę, przekształcając ją w metodę rozszerzenia. W takim przypadku możesz wywołać tę metodę bezpośrednio w komórce, aby scalić zakres komórek, na przykład cell1.Merge(cell2).

Konwertuj na komórki połączone poziomo

Czasami nie jest możliwe wykrycie, które komórki zostały scalone, ponieważ niektóre nowsze wersje Microsoft Word nie używają już flag scalania podczas łączenia komórek w poziomie. Jednak w sytuacjach, gdy komórki są łączone w komórkę poziomo według ich szerokości przy użyciu flag scalania, Aspose.Words udostępnia metodę ConvertToHorizontallyMergedCells do konwersji komórek. Ta metoda po prostu przekształca tabelę i w razie potrzeby dodaje nowe komórki.

Poniższy przykład kodu ilustruje działanie powyższej metody:

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