Trabalhar com colunas e linhas
Para ter mais controle sobre o funcionamento das tabelas, aprenda como manipular colunas e linhas.
Encontrando o índice do elemento da tabela
Colunas, linhas e células são gerenciadas acessando o nó do documento selecionado por meio de seu índice. Encontrar o índice de qualquer nó envolve reunir todos os nós filhos do tipo de elemento do nó pai e, em seguida, usar o método IndexOf para encontrar o índice do nó desejado na coleção.
Encontrando o índice de uma tabela em um documento
Às vezes, pode ser necessário fazer alterações em uma tabela específica de um documento. Para fazer isso, você pode consultar uma tabela pelo seu índice.
O exemplo de código a seguir mostra como recuperar o índice de uma tabela em um documento:
# 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) |
Encontrando o índice de uma linha em uma tabela
Da mesma forma, pode ser necessário fazer alterações em uma linha específica de uma tabela selecionada. Para fazer isso, você também pode referir-se a uma linha pelo seu índice.
O exemplo de código a seguir mostra como recuperar o índice de uma linha em uma tabela:
# 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) |
Encontrando o índice de uma célula consecutiva
Finalmente, pode ser necessário fazer alterações em uma célula específica, e você também pode fazer isso por índice de célula.
O exemplo de código a seguir mostra como recuperar o índice de uma célula em uma linha:
# 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]) |
Trabalhar com colunas
No Aspose.Words Document Object Model (DOM), o nó Table consiste em nós Row e depois em nós Cell. Assim, no Modelo de Objeto Document
do Aspose.Words, assim como nos documentos Word, não existe o conceito de coluna.
Por design, as linhas da tabela em Microsoft Word e Aspose.Words são completamente independentes e as propriedades e operações básicas estão contidas apenas nas linhas e células da tabela. Isso dá às tabelas a capacidade de ter alguns atributos interessantes:
- Cada linha da tabela pode ter um número de células completamente diferente
- Verticalmente, as células de cada linha podem ter larguras diferentes
- É possível unir tabelas com diferentes formatos de linha e número de células
Quaisquer operações executadas em colunas são, na verdade, “atalhos” que executam a operação alterando coletivamente as células da linha de forma que pareça que estão sendo aplicadas às colunas. Ou seja, você pode realizar operações em colunas simplesmente iterando no mesmo índice de célula de linha da tabela.
O exemplo de código a seguir simplifica tais operações provando uma classe de fachada que coleta as células que compõem uma “coluna” de uma tabela:
# 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 | |
O exemplo de código a seguir mostra como inserir uma coluna em branco em uma tabela:
# 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)))) |
O exemplo de código a seguir mostra como remover uma coluna de uma tabela em um documento:
# 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() |
Especifique linhas como linhas de cabeçalho
Você pode optar por repetir a primeira linha da tabela como linha de cabeçalho somente na primeira página ou em cada página se a tabela estiver dividida em várias. No Aspose.Words, você pode repetir a linha do cabeçalho em todas as páginas usando a propriedade HeadingFormat.
Você também pode marcar várias linhas de cabeçalho se essas linhas estiverem localizadas uma após a outra no início da tabela. Para fazer isso, você precisa aplicar as propriedades HeadingFormat a essas linhas.
O exemplo de código a seguir mostra como construir uma tabela que inclui linhas de cabeçalho que se repetem nas páginas subsequentes:
# 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") |
Evite que tabelas e linhas se quebrem nas páginas
Há momentos em que o conteúdo de uma tabela não deve ser dividido em páginas. Por exemplo, se um título estiver acima de uma tabela, o título e a tabela deverão ser sempre mantidos juntos na mesma página para preservar a aparência adequada.
Existem duas técnicas distintas que são úteis para obter essa funcionalidade:
Allow row break across pages
, que é aplicado às linhas da tabelaKeep with next
, que é aplicado a parágrafos em células de tabela
Por padrão, as propriedades acima estão desativadas.
Evite que uma linha se espalhe pelas páginas
Isso envolve impedir que o conteúdo dentro das células de uma linha seja dividido em uma página. No Microsoft Word, isso pode ser encontrado em Propriedades da tabela como a opção “Permitir que a linha se quebre nas páginas”. Em Aspose.Words, isso é encontrado no objeto RowFormat de um Row como propriedade RowFormat.AllowBreakAcrossPages.
O exemplo de código a seguir mostra como desabilitar a quebra de linhas nas páginas para cada linha de uma tabela:
# 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") |
Evite que uma tabela se quebre nas páginas
Para impedir que a tabela se divida entre páginas, precisamos especificar que queremos que o conteúdo contido na tabela permaneça junto.
Para fazer isso, Aspose.Words usa um método que permite aos usuários selecionar uma tabela e habilitar o parâmetro KeepWithNext para true para cada parágrafo dentro das células da tabela. A exceção é o último parágrafo da tabela, que deve ser definido como false.
O exemplo de código a seguir mostra como configurar uma tabela para permanecer junta na mesma página:
# 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") |