Lavora con colonne e righe

Per un maggiore controllo sul funzionamento delle tabelle, scopri come manipolare colonne e righe.

Trovare l’indice degli elementi della tabella

Colonne, righe e celle vengono gestite accedendo al nodo del documento selezionato tramite il suo indice. Trovare l’indice di qualsiasi nodo implica raccogliere tutti i nodi figli del tipo di elemento dal nodo genitore e quindi utilizzare il metodo IndexOf per trovare l’indice del nodo desiderato nella raccolta.

Trovare l’indice di una tabella in un documento

A volte potrebbe essere necessario apportare modifiche a una tabella particolare in un documento. Per fare ciò, puoi fare riferimento a una tabella tramite il suo indice.

L’esempio di codice seguente mostra come recuperare l’indice di una tabella in un 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)

Trovare l’indice di una riga in una tabella

Allo stesso modo, potrebbe essere necessario apportare modifiche a una riga specifica in una tabella selezionata. Per fare ciò, puoi anche fare riferimento a una riga tramite il suo indice.

L’esempio di codice seguente mostra come recuperare l’indice di una riga in una tabella:

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

Trovare l’indice di una cella in una riga

Infine, potrebbe essere necessario apportare modifiche a una cella specifica e puoi farlo anche tramite l’indice della cella.

L’esempio di codice seguente mostra come recuperare l’indice di una cella in una riga:

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

Lavora con le colonne

Nel Aspose.Words Document Object Model (DOM), il nodo Table è costituito da nodi Row e quindi da nodi Cell. Pertanto, nel modello a oggetti Document di Aspose.Words, come nei documenti di Word, non esiste il concetto di colonna.

Per impostazione predefinita, le righe della tabella in Microsoft Word e Aspose.Words sono completamente indipendenti e le proprietà e le operazioni di base sono contenute solo nelle righe e nelle celle della tabella. Ciò dà alle tabelle la possibilità di avere alcuni attributi interessanti:

  • Ogni riga della tabella può avere un numero di celle completamente diverso
  • In verticale, le celle di ciascuna riga possono avere larghezze diverse
  • È possibile unire tabelle con diversi formati di riga e numero di celle

Qualsiasi operazione eseguita sulle colonne è in realtà “scorciatoia” che esegue l’operazione modificando collettivamente le celle della riga in modo tale da sembrare applicate alle colonne. Cioè, puoi eseguire operazioni sulle colonne semplicemente eseguendo un’iterazione sullo stesso indice di cella della riga della tabella.

Il seguente esempio di codice semplifica tali operazioni dimostrando una classe di facciata che raccoglie le celle che compongono una “colonna” di una tabella:

# 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

L’esempio di codice seguente mostra come inserire una colonna vuota in una tabella:

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

L’esempio di codice seguente mostra come rimuovere una colonna da una tabella in un 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()

Specificare le righe come righe di intestazione

Puoi scegliere di ripetere la prima riga della tabella come riga di intestazione solo sulla prima pagina o su ogni pagina se la tabella è divisa in più parti. In Aspose.Words, puoi ripetere la riga di intestazione su ogni pagina utilizzando la proprietà HeadingFormat.

Puoi anche contrassegnare più righe di intestazione se tali righe si trovano una dopo l’altra all’inizio della tabella. Per fare ciò, è necessario applicare le proprietà HeadingFormat a queste righe.

L’esempio di codice seguente mostra come creare una tabella che includa righe di intestazione che si ripetono nelle pagine successive:

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

Evita che tabelle e righe si dividano tra le pagine

Ci sono momenti in cui il contenuto di una tabella non deve essere suddiviso tra le pagine. Ad esempio, se un titolo si trova sopra una tabella, il titolo e la tabella dovrebbero essere sempre tenuti insieme sulla stessa pagina per preservarne l’aspetto corretto.

Esistono due tecniche separate utili per ottenere questa funzionalità:

  • Allow row break across pages, che viene applicato alle righe della tabella
  • Keep with next, che viene applicato ai paragrafi nelle celle della tabella

Per impostazione predefinita, le proprietà di cui sopra sono disabilitate.

Evitare che una riga si rompa tra le pagine

Ciò comporta la limitazione della suddivisione del contenuto all’interno delle celle di una riga su una pagina. In Microsoft Word, questo può essere trovato sotto Proprietà tabella come opzione “Consenti alla riga di suddividersi tra le pagine”. In Aspose.Words questo si trova sotto l’oggetto RowFormat di un Row come proprietà RowFormat.AllowBreakAcrossPages.

L’esempio di codice seguente mostra come disabilitare l’interruzione delle righe tra le pagine per ogni riga in una tabella:

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

Evitare che una tabella si divida tra le pagine

Per evitare che la tabella si divida su più pagine, dobbiamo specificare che vogliamo che il contenuto contenuto nella tabella rimanga insieme.

Per fare ciò, Aspose.Words utilizza un metodo che consente agli utenti di selezionare una tabella e abilitare il parametro KeepWithNext in true per ciascun paragrafo all’interno delle celle della tabella. L’eccezione è l’ultimo paragrafo della tabella, che dovrebbe essere impostato su false.

L’esempio di codice seguente mostra come impostare una tabella in modo che rimanga insieme sulla stessa pagina:

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