Pracuj z kolumnami i wierszami

Aby uzyskać większą kontrolę nad działaniem tabel, dowiedz się, jak manipulować kolumnami i wierszami.

Znajdowanie indeksu elementu tabeli

Zarządzanie kolumnami, wierszami i komórkami odbywa się poprzez dostęp do wybranego węzła dokumentu według jego indeksu. Znalezienie indeksu dowolnego węzła polega na zebraniu wszystkich węzłów podrzędnych typu elementu z węzła nadrzędnego, a następnie zastosowaniu metody IndexOf w celu znalezienia indeksu żądanego węzła w kolekcji.

Znajdowanie indeksu tabeli w dokumencie

Czasami może być konieczne wprowadzenie zmian w określonej tabeli w dokumencie. Aby to zrobić, możesz odwołać się do tabeli po jej indeksie.

Poniższy przykład kodu pokazuje, jak pobrać indeks tabeli w dokumencie:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
all_tables = doc.get_child_nodes(aw.NodeType.TABLE, True)
table_index = all_tables.index_of(table)

Znajdowanie indeksu wiersza w tabeli

Podobnie może być konieczne wprowadzenie zmian w konkretnym wierszu w wybranej tabeli. Aby to zrobić, możesz także odwołać się do wiersza po jego indeksie.

Poniższy przykład kodu pokazuje, jak pobrać indeks wiersza w tabeli:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
row_index = table.index_of(table.last_row)

Znajdowanie indeksu komórki w wierszu

Na koniec może zaistnieć potrzeba wprowadzenia zmian w określonej komórce i można to zrobić również na podstawie indeksu komórki.

Poniższy przykład kodu pokazuje, jak pobrać indeks komórki w wierszu:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
cell_index = row.index_of(row.cells[4])

Pracuj z kolumnami

W Aspose.Words Document Object Model (DOM) węzeł Table składa się z węzłów Row, a następnie węzłów Cell. Zatem w modelu obiektowym Document Aspose.Words, podobnie jak w dokumentach programu Word, nie ma pojęcia kolumny.

Z założenia wiersze tabeli w Microsoft Word i Aspose.Words są całkowicie niezależne, a podstawowe właściwości i operacje zawarte są tylko w wierszach i komórkach tabeli. Dzięki temu tabele mogą mieć kilka interesujących atrybutów:

  • Każdy wiersz tabeli może mieć zupełnie inną liczbę komórek
  • W pionie komórki każdego wiersza mogą mieć różną szerokość
  • Możliwe jest łączenie tabel o różnych formatach wierszy i liczbie komórek

Wszelkie operacje wykonywane na kolumnach są w rzeczywistości “skrótami”, które wykonują operację poprzez zbiorczą zmianę komórek wierszy w taki sposób, że wygląda to tak, jakby były stosowane do kolumn. Oznacza to, że możesz wykonywać operacje na kolumnach, po prostu iterując po tym samym indeksie komórki wiersza tabeli.

Poniższy przykład kodu upraszcza takie operacje, udowadniając klasę fasadową, która zbiera komórki tworzące “kolumnę” tabeli:

# For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Python-via-.NET.git.
class Column:
"""Represents a facade object for a column of a table in a Microsoft Word document."""
def __init__(self, table: aw.tables.Table, column_index: int):
if table is None:
raise ValueError("table")
self.table = table
self.column_index = column_index
def index_of(self, cell: aw.tables.Cell):
"""Returns the index of the given cell in the column."""
return self.get_column_cells().index(cell)
def insert_column_before(self):
"""Inserts a brand new column before this column into the table."""
column_cells = self.get_column_cells()
if len(column_cells) == 0:
raise ValueError("Column must not be empty")
# Create a clone of this column.
for cell in column_cells:
cell.parent_row.insert_before(cell.clone(False), cell)
# This is the new column.
column = self.__class__(column_cells[0].parent_row.parent_table, self.column_index)
# We want to make sure that the cells are all valid to work with (have at least one paragraph).
for cell in column.get_column_cells():
cell.ensure_minimum()
# Increase the index which this column represents since there is now one extra column in front.
self.column_index += 1
return column
def remove(self):
"""Removes the column from the table."""
for cell in self.get_column_cells():
cell.remove()
def to_txt(self):
"""Returns the text of the column."""
return "".join(cell.to_string(aw.SaveFormat.TEXT) for cell in self.get_column_cells())
def get_column_cells(self):
"""Provides an up-to-date collection of cells which make up the column represented by this facade."""
column_cells = []
for row in self.table.rows:
cell = row.as_row().cells[self.column_index]
if cell is not None:
column_cells.append(cell)
return column_cells
view raw column-class.py hosted with ❤ by GitHub

Poniższy przykład kodu pokazuje, jak wstawić pustą kolumnę do tabeli:

# 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 + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
column = self.Column(table, 0)
# Print the plain text of the column to the screen.
print(column.to_txt())
# Create a new column to the left of this column.
# This is the same as using the "Insert Column Before" command in Microsoft Word.
new_column = column.insert_column_before()
for cell in new_column.get_column_cells():
cell.first_paragraph.append_child(aw.Run(doc, "Column Text " + str(new_column.index_of(cell))))

Poniższy przykład kodu pokazuje, jak usunąć kolumnę z tabeli w dokumencie:

# 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 + "Tables.docx")
table = doc.get_child(aw.NodeType.TABLE, 1, True).as_table()
column = self.Column(table, 2)
column.remove()

Określ wiersze jako wiersze nagłówka

Możesz powtórzyć pierwszy wiersz tabeli jako wiersz nagłówka tylko na pierwszej stronie lub na każdej stronie, jeśli tabela jest podzielona na kilka. W Aspose.Words możesz powtórzyć wiersz nagłówka na każdej stronie, korzystając z właściwości HeadingFormat.

Można także zaznaczyć wiele wierszy nagłówka, jeśli takie wiersze znajdują się jeden po drugim na początku tabeli. Aby to zrobić, musisz zastosować właściwości HeadingFormat do tych wierszy.

Poniższy przykład kodu pokazuje, jak zbudować tabelę zawierającą wiersze nagłówka powtarzające się na kolejnych stronach:

# 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.start_table()
builder.row_format.heading_format = True
builder.paragraph_format.alignment = aw.ParagraphAlignment.CENTER
builder.cell_format.width = 100
builder.insert_cell()
builder.writeln("Heading row 1")
builder.end_row()
builder.insert_cell()
builder.writeln("Heading row 2")
builder.end_row()
builder.cell_format.width = 50
builder.paragraph_format.clear_formatting()
for _ in range(50):
builder.insert_cell()
builder.row_format.heading_format = False
builder.write("Column 1 Text")
builder.insert_cell()
builder.write("Column 2 Text")
builder.end_row()
doc.save(ARTIFACTS_DIR + "WorkingWithTables.repeat_rows_on_subsequent_pages.docx")

Zapobiegaj rozbijaniu tabel i wierszy między stronami

Są sytuacje, w których zawartość tabeli nie powinna być dzielona na strony. Na przykład, jeśli tytuł znajduje się nad tabelą, tytuł i tabela powinny być zawsze przechowywane razem na tej samej stronie, aby zachować właściwy wygląd.

Aby osiągnąć tę funkcjonalność, przydatne są dwie oddzielne techniki:

  • Allow row break across pages, który jest stosowany do wierszy tabeli
  • Keep with next, który jest stosowany do akapitów w komórkach tabeli

Domyślnie powyższe właściwości są wyłączone.

Zapobiegnij przerywaniu wiersza między stronami

Wiąże się to z ograniczeniem podziału treści znajdujących się w komórkach wiersza na stronie. W Microsoft Word można to znaleźć we Właściwościach tabeli jako opcję “Pozwól wierszowi na dzielenie stron”. W Aspose.Words można to znaleźć w obiekcie RowFormat Row jako właściwość RowFormat.AllowBreakAcrossPages.

Poniższy przykład kodu pokazuje, jak wyłączyć dzielenie wierszy na stronach dla każdego wiersza w tabeli:

# 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 spanning two pages.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
# Disable breaking across pages for all rows in the table.
for row in table.rows:
row.as_row().row_format.allow_break_across_pages = False
doc.save(ARTIFACTS_DIR + "WorkingWithTables.row_format_disable_break_across_pages.docx")

Chroń tabelę przed pękaniem między stronami

Aby zapobiec podziałowi tabeli na strony, musimy określić, że chcemy, aby treść zawarta w tabeli pozostała razem.

Aby to zrobić, Aspose.Words wykorzystuje metodę, która pozwala użytkownikom wybrać tabelę i włączyć parametr KeepWithNext do formatu true dla każdego akapitu w komórkach tabeli. Wyjątkiem jest ostatni akapit w tabeli, który powinien być ustawiony na false.

Poniższy przykład kodu pokazuje, jak ustawić tabelę tak, aby znajdowała się razem na tej samej stronie:

# 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 spanning two pages.docx")
table = doc.get_child(aw.NodeType.TABLE, 0, True).as_table()
# We need to enable KeepWithNext for every paragraph in the table to keep it from breaking across a page,
# except for the last paragraphs in the last row of the table.
for cell in table.get_child_nodes(aw.NodeType.CELL, True):
cell = cell.as_cell()
cell.ensure_minimum()
for para in cell.paragraphs:
para = para.as_paragraph()
if not (cell.parent_row.is_last_row and para.is_end_of_cell):
para.paragraph_format.keep_with_next = True
doc.save(ARTIFACTS_DIR + "WorkingWithTables.keep_table_together.docx")