Travailler avec des Colonnes et des Lignes

Pour mieux contrôler le fonctionnement des tableaux, apprenez à manipuler les colonnes et les lignes.

Trouver l’index des éléments de la Table

Les colonnes, les lignes et les cellules sont gérées en accédant au nœud de 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.

Trouver l’index d’une Table dans un Document

Parfois, vous devrez peut-être apporter des modifications à une table particulière d’un document. Pour ce faire, vous pouvez vous référer à 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-Java.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 un tableau

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 vous référer à 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-Java.git.
int rowIndex = table.indexOf(table.getLastRow());

Trouver l’index d’une cellule dans une rangée

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 d’une ligne:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
int cellIndex = row.indexOf(row.getCells().get(4));

Travailler avec des colonnes

Dans le modèle d’objet de document Aspose.Words (DOM), le nœud Table se compose 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 concept 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 ne sont contenues que dans les lignes et les cellules du tableau. Cela donne aux tableaux 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 nombre 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 de ligne de telle sorte qu’il semble qu’elles soient appliquées aux colonnes. Autrement dit, vous pouvez effectuer des opérations sur les colonnes en itérant simplement sur le même index de cellule de ligne de tableau.

L’exemple de code suivant simplifie de telles opérations en prouvant une classe de façade qui collecte les cellules qui composent une “colonne” d’une table:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
/// <summary>
/// Represents a facade object for a column of a table in a Microsoft Word document.
/// </summary>
static class Column
{
    private Column(Table table, int columnIndex) {
        if (table != null) {
            mTable = table;
        } else {
            throw new IllegalArgumentException("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);
    }

    private ArrayList<Cell> getCells() {
        return getColumnCells();
    }

    /// <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()
    {
        ArrayList<Cell> columnCells = getCells();

        if (columnCells.size() == 0)
            throw new IllegalArgumentException("Column must not be empty");

        // Create a clone of this column.
        for (Cell cell : columnCells)
            cell.getParentRow().insertBefore(cell.deepClone(false), cell);

        // This is the new column.
        Column column = new Column(columnCells.get(0).getParentRow().getParentTable(), mColumnIndex);

        // We want to make sure that the cells are all valid to work with (have at least one paragraph).
        for (Cell cell : column.getCells())
            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()
    {
        for (Cell cell : getCells())
            cell.remove();
    }

    /// <summary>
    /// Returns the text of the column. 
    /// </summary>
    public String toTxt() throws Exception
    {
        StringBuilder builder = new StringBuilder();

        for (Cell cell : getCells())
            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 ArrayList<Cell> getColumnCells()
    {
        ArrayList<Cell> columnCells = new ArrayList<Cell>();

        for (Row row : mTable.getRows())
        {
            Cell cell = row.getCells().get(mColumnIndex);
            if (cell != null)
                columnCells.add(cell);
        }

        return columnCells;
    }

    private int mColumnIndex;
    private Table mTable;
}

L’exemple de code suivant montre comment insérer une colonne vide dans un tableau:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "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.
System.out.println(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();

for (Cell cell : newColumn.getColumnCells())
    cell.getFirstParagraph().appendChild(new Run(doc, "Column Text " + newColumn.indexOf(cell)));

L’exemple de code suivant montre comment supprimer une colonne d’un tableau dans un document:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Tables.docx");

Table table = (Table) doc.getChild(NodeType.TABLE, 1, true);

Column column = Column.fromIndex(table, 2);
column.remove();

Spécifier des lignes comme Lignes d’en-tête

Vous pouvez choisir de répéter la première ligne du tableau en tant que 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 sont situées l’une après l’autre au début du tableau. Pour ce faire, vous devez appliquer les propriétés HeadingFormat à ces lignes.

Notez que les lignes d’en-tête ne fonctionnent pas dans les tables imbriquées. Autrement dit, si vous avez une table à l’intérieur d’une autre table, ce paramètre n’aura aucun effet. C’est une limitation de Microsoft Word qui ne le permet pas, pas Aspose.Words.

L’exemple de code suivant montre comment créer un tableau qui inclut 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-Java.git.
Document doc = new Document();
DocumentBuilder builder = new DocumentBuilder(doc);

builder.startTable();
builder.getRowFormat().setHeadingFormat(true);
builder.getParagraphFormat().setAlignment(ParagraphAlignment.CENTER);
builder.getCellFormat().setWidth(100.0);
builder.insertCell();
builder.writeln("Heading row 1");
builder.endRow();
builder.insertCell();
builder.writeln("Heading row 2");
builder.endRow();

builder.getCellFormat().setWidth(50.0);
builder.getParagraphFormat().clearFormatting();

for (int i = 0; i < 50; i++)
{
    builder.insertCell();
    builder.getRowFormat().setHeadingFormat(false);
    builder.write("Column 1 Text");
    builder.insertCell();
    builder.write("Column 2 Text");
    builder.endRow();
}

doc.save(getArtifactsDir() + "WorkingWithTables.RepeatRowsOnSubsequentPages.docx");

Empêchez les Tableaux et les Lignes de Se Briser Sur les Pages

Il y a des moments où le contenu d’un tableau ne doit pas être réparti sur plusieurs pages. Par exemple, si un titre est au-dessus d’un tableau, le titre et le tableau doivent toujours être conservés ensemble sur la même page pour préserver l’apparence appropriée.

Il existe deux techniques distinctes qui sont utiles pour atteindre cette fonctionnalité:

• Allow row break across pages, qui est appliqué aux lignes du tableau
• Keep with next, qui est appliqué aux paragraphes dans les cellules du tableau

Par défaut, les propriétés ci-dessus sont désactivées.

Empêche une Ligne de Traverser les Pages

Cela implique de restreindre le contenu à l’intérieur des cellules d’une ligne d’être divisé sur une page. Dans Microsoft Word, cela se trouve sous les propriétés du tableau sous l’option “Autoriser la ligne à traverser les pages”. Dans 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 entre les pages pour chaque ligne d’un tableau:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
Document doc = new Document(getMyDir() + "Table spanning two pages.docx");

Table table = (Table) doc.getChild(NodeType.TABLE, 0, true);

// Disable breaking across pages for all rows in the table.
for (Row row : (Iterable<Row>) table.getRows())
    row.getRowFormat().setAllowBreakAcrossPages(false);

doc.save(getArtifactsDir() + "WorkingWithTables.RowFormatDisableBreakAcrossPages.docx");

Empêcher une Table de Se Briser Sur les Pages

Pour empêcher le tableau de se diviser entre les pages, nous devons spécifier que nous voulons que le contenu contenu dans le tableau reste uni.

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 sur 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-Java.git.
Document doc = new Document(getMyDir() + "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.
for (Cell cell : (Iterable<Cell>) table.getChildNodes(NodeType.CELL, true))
{
    cell.ensureMinimum();

    for (Paragraph para : (Iterable<Paragraph>) cell.getParagraphs())
        if (!(cell.getParentRow().isLastRow() && para.isEndOfCell()))
            para.getParagraphFormat().setKeepWithNext(true);
}

doc.save(getArtifactsDir() + "WorkingWithTables.KeepTableTogether.docx");