Travailler avec des colonnes et des lignes
Pour mieux contrôler le fonctionnement des tableaux, découvrez comment manipuler les colonnes et les lignes.
Trouver l’index des éléments de table
Les colonnes, lignes et cellules sont gérées en accédant au nœud du document sélectionné par son index. Trouver l’index de n’importe quel nœud implique de rassembler tous les nœuds enfants du type d’élément à partir du nœud parent, puis d’utiliser la méthode IndexOf pour trouver l’index du nœud souhaité dans la collection.
Rechercher l’index d’une table dans un document
Parfois, vous devrez peut-être apporter des modifications à un tableau particulier d’un document. Pour ce faire, vous pouvez faire référence à une table par son index.
L’exemple de code suivant montre comment récupérer l’index d’une table dans un document:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Table table = (Table) doc.GetChild(NodeType.Table, 0, true); | |
NodeCollection allTables = doc.GetChildNodes(NodeType.Table, true); | |
int tableIndex = allTables.IndexOf(table); |
Trouver l’index d’une ligne dans une table
De même, vous devrez peut-être apporter des modifications à une ligne spécifique d’un tableau sélectionné. Pour ce faire, vous pouvez également faire référence à une ligne par son index.
L’exemple de code suivant montre comment récupérer l’index d’une ligne dans une table:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
int rowIndex = table.IndexOf(table.LastRow); |
Trouver l’index d’une cellule dans une ligne
Enfin, vous devrez peut-être apporter des modifications à une cellule spécifique, et vous pouvez également le faire par index de cellule.
L’exemple de code suivant montre comment récupérer l’index d’une cellule dans une ligne:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
int cellIndex = row.IndexOf(row.Cells[4]); |
Travailler avec des colonnes
Dans le Aspose.Words Document Object Model (DOM), le nœud Table est constitué de nœuds Row puis de nœuds Cell. Ainsi, dans le modèle objet Document
de Aspose.Words, comme dans les documents Word, il n’y a pas de notion de colonne.
De par leur conception, les lignes du tableau dans Microsoft Word et Aspose.Words sont complètement indépendantes et les propriétés et opérations de base sont contenues uniquement dans les lignes et les cellules du tableau. Cela donne aux tables la possibilité d’avoir des attributs intéressants:
- Chaque ligne du tableau peut avoir un nombre de cellules complètement différent
- Verticalement, les cellules de chaque rangée peuvent avoir des largeurs différentes
- Il est possible de joindre des tableaux avec différents formats de lignes et nombres de cellules
Toutes les opérations effectuées sur les colonnes sont en fait des “raccourcis” qui effectuent l’opération en modifiant collectivement les cellules des lignes de telle manière qu’elles semblent être appliquées aux colonnes. Autrement dit, vous pouvez effectuer des opérations sur les colonnes en parcourant simplement le même index de cellule de ligne de tableau.
L’exemple de code suivant simplifie ces opérations en prouvant une classe de façade qui collecte les cellules qui composent une “colonne” d’un tableau:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
/// <summary> | |
/// Represents a facade object for a column of a table in a Microsoft Word document. | |
/// </summary> | |
internal class Column | |
{ | |
private Column(Table table, int columnIndex) | |
{ | |
mTable = table ?? throw new ArgumentException("table"); | |
mColumnIndex = columnIndex; | |
} | |
/// <summary> | |
/// Returns a new column facade from the table and supplied zero-based index. | |
/// </summary> | |
public static Column FromIndex(Table table, int columnIndex) | |
{ | |
return new Column(table, columnIndex); | |
} | |
/// <summary> | |
/// Returns the cells which make up the column. | |
/// </summary> | |
public Cell[] Cells => GetColumnCells().ToArray(); | |
/// <summary> | |
/// Returns the index of the given cell in the column. | |
/// </summary> | |
public int IndexOf(Cell cell) | |
{ | |
return GetColumnCells().IndexOf(cell); | |
} | |
/// <summary> | |
/// Inserts a brand new column before this column into the table. | |
/// </summary> | |
public Column InsertColumnBefore() | |
{ | |
Cell[] columnCells = Cells; | |
if (columnCells.Length == 0) | |
throw new ArgumentException("Column must not be empty"); | |
// Create a clone of this column. | |
foreach (Cell cell in columnCells) | |
cell.ParentRow.InsertBefore(cell.Clone(false), cell); | |
// This is the new column. | |
Column column = new Column(columnCells[0].ParentRow.ParentTable, mColumnIndex); | |
// We want to make sure that the cells are all valid to work with (have at least one paragraph). | |
foreach (Cell cell in column.Cells) | |
cell.EnsureMinimum(); | |
// Increase the index which this column represents since there is now one extra column in front. | |
mColumnIndex++; | |
return column; | |
} | |
/// <summary> | |
/// Removes the column from the table. | |
/// </summary> | |
public void Remove() | |
{ | |
foreach (Cell cell in Cells) | |
cell.Remove(); | |
} | |
/// <summary> | |
/// Returns the text of the column. | |
/// </summary> | |
public string ToTxt() | |
{ | |
StringBuilder builder = new StringBuilder(); | |
foreach (Cell cell in Cells) | |
builder.Append(cell.ToString(SaveFormat.Text)); | |
return builder.ToString(); | |
} | |
/// <summary> | |
/// Provides an up-to-date collection of cells which make up the column represented by this facade. | |
/// </summary> | |
private List<Cell> GetColumnCells() | |
{ | |
List<Cell> columnCells = new List<Cell>(); | |
foreach (Row row in mTable.Rows) | |
{ | |
Cell cell = row.Cells[mColumnIndex]; | |
if (cell != null) | |
columnCells.Add(cell); | |
} | |
return columnCells; | |
} | |
private int mColumnIndex; | |
private readonly Table mTable; | |
} |
L’exemple de code suivant montre comment insérer une colonne vide dans une table:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(MyDir + "Tables.docx"); | |
Table table = (Table) doc.GetChild(NodeType.Table, 0, true); | |
Column column = Column.FromIndex(table, 0); | |
// Print the plain text of the column to the screen. | |
Console.WriteLine(column.ToTxt()); | |
// Create a new column to the left of this column. | |
// This is the same as using the "Insert Column Before" command in Microsoft Word. | |
Column newColumn = column.InsertColumnBefore(); | |
foreach (Cell cell in newColumn.Cells) | |
cell.FirstParagraph.AppendChild(new Run(doc, "Column Text " + newColumn.IndexOf(cell))); |
L’exemple de code suivant montre comment supprimer une colonne d’une table dans un document:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(MyDir + "Tables.docx"); | |
Table table = (Table) doc.GetChild(NodeType.Table, 1, true); | |
Column column = Column.FromIndex(table, 2); | |
column.Remove(); |
Spécifier les lignes comme lignes d’en-tête
Vous pouvez choisir de répéter la première ligne du tableau comme ligne d’en-tête uniquement sur la première page ou sur chaque page si le tableau est divisé en plusieurs. Dans Aspose.Words, vous pouvez répéter la ligne d’en-tête sur chaque page à l’aide de la propriété HeadingFormat.
Vous pouvez également marquer plusieurs lignes d’en-tête si ces lignes se trouvent les unes après les autres au début du tableau. Pour ce faire, vous devez appliquer les propriétés HeadingFormat à ces lignes.
L’exemple de code suivant montre comment créer un tableau comprenant des lignes d’en-tête qui se répètent sur les pages suivantes:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(); | |
DocumentBuilder builder = new DocumentBuilder(doc); | |
builder.StartTable(); | |
builder.RowFormat.HeadingFormat = true; | |
builder.ParagraphFormat.Alignment = ParagraphAlignment.Center; | |
builder.CellFormat.Width = 100; | |
builder.InsertCell(); | |
builder.Writeln("Heading row 1"); | |
builder.EndRow(); | |
builder.InsertCell(); | |
builder.Writeln("Heading row 2"); | |
builder.EndRow(); | |
builder.CellFormat.Width = 50; | |
builder.ParagraphFormat.ClearFormatting(); | |
for (int i = 0; i < 50; i++) | |
{ | |
builder.InsertCell(); | |
builder.RowFormat.HeadingFormat = false; | |
builder.Write("Column 1 Text"); | |
builder.InsertCell(); | |
builder.Write("Column 2 Text"); | |
builder.EndRow(); | |
} | |
doc.Save(ArtifactsDir + "WorkingWithTables.RepeatRowsOnSubsequentPages.docx"); |
Empêcher les tableaux et les lignes de se diviser entre les pages
Il arrive parfois que le contenu d’un tableau ne doive pas être réparti sur plusieurs pages. Par exemple, si un titre se trouve au-dessus d’un tableau, le titre et le tableau doivent toujours être conservés ensemble sur la même page pour préserver leur apparence.
Il existe deux techniques distinctes utiles pour obtenir cette fonctionnalité:
Allow row break across pages
, qui est appliqué aux lignes du tableauKeep with next
, qui s’applique aux paragraphes des cellules du tableau
Par défaut, les propriétés ci-dessus sont désactivées.
Empêcher une ligne de se diviser entre les pages
Cela implique d’empêcher la répartition du contenu à l’intérieur des cellules d’une ligne sur une page. Dans Microsoft Word, cela se trouve sous Propriétés du tableau sous l’option “Autoriser la séparation des lignes sur plusieurs pages”. En Aspose.Words, cela se trouve sous l’objet RowFormat d’un Row en tant que propriété RowFormat.AllowBreakAcrossPages.
L’exemple de code suivant montre comment désactiver la séparation des lignes sur plusieurs pages pour chaque ligne d’un tableau:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(MyDir + "Table spanning two pages.docx"); | |
Table table = (Table) doc.GetChild(NodeType.Table, 0, true); | |
// Disable breaking across pages for all rows in the table. | |
foreach (Row row in table.Rows) | |
row.RowFormat.AllowBreakAcrossPages = false; | |
doc.Save(ArtifactsDir + "WorkingWithTables.RowFormatDisableBreakAcrossPages.docx"); |
Empêcher un tableau de se diviser en plusieurs pages
Pour empêcher le tableau de se diviser en plusieurs pages, nous devons spécifier que nous souhaitons que le contenu contenu dans le tableau reste ensemble.
Pour ce faire, Aspose.Words utilise une méthode qui permet aux utilisateurs de sélectionner un tableau et d’activer le paramètre KeepWithNext en true pour chaque paragraphe dans les cellules du tableau. L’exception est le dernier paragraphe du tableau, qui doit être défini sur false.
L’exemple de code suivant montre comment définir une table pour qu’elle reste ensemble sur la même page:
// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git. | |
Document doc = new Document(MyDir + "Table spanning two pages.docx"); | |
Table table = (Table) doc.GetChild(NodeType.Table, 0, true); | |
// 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. | |
foreach (Cell cell in table.GetChildNodes(NodeType.Cell, true)) | |
{ | |
cell.EnsureMinimum(); | |
foreach (Paragraph para in cell.Paragraphs) | |
if (!(cell.ParentRow.IsLastRow && para.IsEndOfCell)) | |
para.ParagraphFormat.KeepWithNext = true; | |
} | |
doc.Save(ArtifactsDir + "WorkingWithTables.KeepTableTogether.docx"); |