Werk met kolommen en rijen

Voor meer controle over hoe tabellen werken, leer hoe kolommen en rijen te manipuleren.

De tabelelementindex zoeken

Kolommen, rijen en cellen worden beheerd door toegang te krijgen tot de geselecteerde documentnode door de index. Het vinden van de index van een knooppunt impliceert het verzamelen van alle kindknooppunten van het elementtype van de oudernode, en vervolgens het gebruik van de IndexOf methode om de index van de gewenste knoop in de collectie te vinden.

De index van een tabel vinden in een document

Soms moet u wijzigingen aanbrengen in een bepaalde tabel in een document. Om dit te doen, kunt u verwijzen naar een tabel door de index.

Het volgende voorbeeld van code laat zien hoe je de index van een tabel in een document kunt ophalen:

// 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);

Vind de index van een rij in een tabel

Het kan ook nodig zijn om wijzigingen aan te brengen in een specifieke rij in een geselecteerde tabel. Om dit te doen, kunt u ook verwijzen naar een rij door de index.

Het volgende voorbeeld van code laat zien hoe je de index van een rij in een tabel kunt ophalen:

// 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);

Vind de index van een cel in een rij

Tenslotte moet je misschien wijzigingen aanbrengen in een specifieke cel, en je kunt dit ook doen per celindex.

Het volgende voorbeeld van code laat zien hoe je de index van een cel op een rij ophaalt:

// 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]);

Werk met kolommen

In de Aspose.Words Document Object Model (DOM), de Table knooppunt bestaat uit Row nodes en dan Cell knooppunten. In de Document Objectmodel van Aspose.Words, zoals in Word documenten, is er geen concept van een kolom.

Naar ontwerp, de tabel rijen in Microsoft Word en Aspose.Words zijn volledig onafhankelijk, en de basiseigenschappen en operaties zijn alleen opgenomen in de rijen en cellen van de tabel. Dit geeft tabellen de mogelijkheid om een aantal interessante attributen:

• Elke rij kan een totaal ander aantal cellen hebben
• Verticaal kunnen de cellen van elke rij verschillende breedtes hebben
• Het is mogelijk om tabellen samen te voegen met verschillende rijformaten en aantal cellen

Elke bewerking uitgevoerd op kolommen zijn eigenlijk “shortcuts” die de operatie uitvoeren door collectief van rij cellen op een zodanige manier dat het lijkt alsof ze worden toegepast op kolommen. Dat wil zeggen, je kunt operaties uitvoeren op kolommen door simpelweg te itereren over dezelfde tabel rij cel index.

Het volgende codevoorbeeld vereenvoudigt dergelijke bewerkingen door een gevelklasse te bewijzen die de cellen verzamelt die een “kolom” van een tabel vormen:

// 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;
}

Het volgende voorbeeld van code laat zien hoe je een lege kolom in een tabel invoegt:

// 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)));

Het volgende voorbeeld van code laat zien hoe u een kolom uit een tabel in een document verwijdert:

// 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();

Rijen specificeren als koprijen

U kunt ervoor kiezen om de eerste rij in de tabel te herhalen als de Header Row alleen op de eerste pagina of op elke pagina als de tabel is opgesplitst in meerdere. In Aspose.Words, kunt u de Header Row herhalen op elke pagina met behulp van de HeadingFormat eigendom.

U kunt ook meerdere header rijen markeren als dergelijke rijen zich aan het begin van de tabel bevinden. Om dit te doen, moet u de HeadingFormat eigenschappen van deze rijen.

Merk op dat Header Rows niet werken in geneste tabellen. Dat wil zeggen, als je een tafel in een andere tabel hebt, zal deze instelling geen effect hebben. Het is een beperking van Microsoft Word Dat staat dit niet toe, niet Aspose.Words.

Het volgende codevoorbeeld laat zien hoe een tabel te bouwen die Header Rows bevat die zich herhalen op volgende pagina’s:

// 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");

Houd tabellen en rijen te breken over pagina’s

Er zijn tijden dat de inhoud van een tabel niet over pagina’s moet worden verdeeld. Als bijvoorbeeld een titel boven een tabel staat, moeten de titel en de tabel altijd op dezelfde pagina bij elkaar worden gehouden om het juiste uiterlijk te behouden.

Er zijn twee aparte technieken die nuttig zijn om deze functionaliteit te bereiken:

• Allow row break across pages, die op tabelrijen wordt toegepast
• Keep with next, die wordt toegepast op de alinea’s in tabelcellen

Standaard zijn bovenstaande eigenschappen uitgeschakeld.

Houd een rij van Breaking Acrosh Pages

Dit houdt in dat de inhoud binnen de cellen van een rij moet worden beperkt van opgedeeld over een pagina. In Microsoft Word, Dit kan worden gevonden onder Tabel Eigenschappen als de optie In Aspose.Words Dit wordt gevonden onder de RowFormat object van a Row als eigendom RowFormat.AllowBreakAcrossPages.

Het volgende voorbeeld van code laat zien hoe brekende rijen voor elke rij in een tabel kunnen worden uitgeschakeld:

// 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");

U kunt het voorbeeldbestand van dit voorbeeld downloaden van Aspose.Words GitHub.

Houd een tafel van Breaking Across Pages

Om te voorkomen dat de tabel over pagina’s verdeeld wordt, moeten we specificeren dat we willen dat de inhoud in de tabel bij elkaar blijft.

Om dit te doen, Aspose.Words maakt gebruik van een methode, die gebruikers in staat stelt een tabel te selecteren en de KeepWithNext parameter voor true voor elke alinea binnen de tabelcellen. De uitzondering is de laatste alinea in de tabel, die moet worden vastgesteld op false.

Het volgende voorbeeld van code laat zien hoe u een tabel kunt instellen om samen te blijven op dezelfde pagina:

// 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");

U kunt het voorbeeldbestand van dit voorbeeld downloaden van Aspose.Words GitHub.