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:
- Pierwsza komórka w sekwencji połączonych komórek będzie miała CellMerge.First
- Wszystkie później połączone komórki będą miały CellMerge.Previous
- Komórka, która nie jest scalona, będzie miała CellMerge.None
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 | |
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() |