Tabelcellen samenvoegen

Soms vereisen bepaalde rijen in een tabel een kop of grote blokken tekst die de volledige breedte van de tabel innemen. Voor het juiste ontwerp van de tabel, kan de gebruiker meerdere tabelcellen samenvoegen in een. Aspose.Words ondersteunt samengevoegde cellen bij het werken met alle invoerformaten, inclusief het importeren van HTML-inhoud.

Hoe tabelcellen samenvoegen

In Aspose.Words, samengevoegde cellen worden vertegenwoordigd door de volgende eigenschappen van de CellFormat klasse:

• HorizontalMerge die beschrijft of de cel deel uitmaakt van een horizontale samenvoeging van cellen
• VerticalMerge die beschrijft of de cel deel uitmaakt van een verticale samenvoeging van cellen

De waarden van deze eigenschappen bepalen het samenvoeggedrag van cellen:

• De eerste cel in een reeks samengevoegde cellen zal hebben CellMerge.First
• Elke later samengevoegde cellen zal hebben CellMerge.Previous
• Een cel die niet is samengevoegd zal hebben CellMerge.None

Soms, bij het laden van bestaande documentcellen in een tabel, zullen ze samengevoegd verschijnen. Echter, het kan eigenlijk een lange cel zijn, soms Microsoft Word exporteert samengevoegde cellen op deze manier. Dit kan verwarrend zijn als je met individuele cellen probeert te werken, maar er lijkt geen bepaald patroon te zijn als dit gebeurt.

Controleren of een cel is samengevoegd

Om te controleren of een cel deel uitmaakt van een opeenvolging van samengevoegde cellen, controleren we gewoon de HorizontalMerge en VerticalMerge eigenschappen.

Het volgende voorbeeld van code laat zien hoe het horizontale en verticale cel merge type af te drukken:

// 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 with merged cells.docx");

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

for (Row row : (Iterable<Row>) table.getRows())
{
    for (Cell cell : (Iterable<Cell>) row.getCells())
    {
        System.out.println(printCellMergeType(cell));
    }
}

Tabelcellen samenvoegen bij gebruik van DocumentBuilder

Het samenvoegen van cellen in een tabel gemaakt met de DocumentBuilder, u moet het juiste mergetype instellen voor elke cel waar de merge wordt verwacht CellMerge.First en dan CellMerge.Previous.

Ook moet je onthouden om de merge instelling voor die cellen waar geen merge nodig is te wissen CellMerge.None. Als dit niet gebeurt, worden alle cellen in de tabel samengevoegd.

Het volgende voorbeeld van code laat zien hoe je een tabel maakt met twee rijen waar de cellen in de eerste rij horizontaal worden samengevoegd:

// 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.insertCell();
builder.getCellFormat().setHorizontalMerge(CellMerge.FIRST);
builder.write("Text in merged cells.");

builder.insertCell();
// This cell is merged to the previous and should be empty.
builder.getCellFormat().setHorizontalMerge(CellMerge.PREVIOUS);
builder.endRow();

builder.insertCell();
builder.getCellFormat().setHorizontalMerge(CellMerge.NONE);
builder.write("Text in one cell.");

builder.insertCell();
builder.write("Text in another cell.");
builder.endRow();
builder.endTable();
        
doc.save(getArtifactsDir() + "WorkingWithTables.HorizontalMerge.docx");

Het volgende voorbeeld van code laat zien hoe je een tabel met twee kolommen aanmaakt waarbij de cellen in de eerste kolom verticaal zijn samengevoegd:

// 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.insertCell();
builder.getCellFormat().setVerticalMerge(CellMerge.FIRST);
builder.write("Text in merged cells.");

builder.insertCell();
builder.getCellFormat().setVerticalMerge(CellMerge.NONE);
builder.write("Text in one cell");
builder.endRow();

builder.insertCell();
// This cell is vertically merged to the cell above and should be empty.
builder.getCellFormat().setVerticalMerge(CellMerge.PREVIOUS);

builder.insertCell();
builder.getCellFormat().setVerticalMerge(CellMerge.NONE);
builder.write("Text in another cell");
builder.endRow();
builder.endTable();
        
doc.save(getArtifactsDir() + "WorkingWithTables.VerticalMerge.docx");

Tabelcellen samenvoegen in andere gevallen

In andere situaties DocumentBuilder wordt niet gebruikt, zoals in een bestaande tabel, het samenvoegen van cellen op de vorige manier kan niet zo gemakkelijk zijn. In plaats daarvan kunnen we de basisbewerkingen die betrokken zijn bij het toepassen van merge eigenschappen op cellen in een methode die de taak veel gemakkelijker maakt. Deze methode is vergelijkbaar met de Samenvoeg automatiseringsmethode, die wordt opgeroepen om een reeks cellen in een tabel samen te voegen.

De onderstaande code zal de tabelcellen samenvoegen in het opgegeven bereik, beginnend bij de gegeven cel en eindigend bij de eindcel. In dit geval kan het bereik meerdere rijen of kolommen omvatten:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
void mergeCells(Cell startCell, Cell endCell)
{
    Table parentTable = startCell.getParentRow().getParentTable();

    // Find the row and cell indices for the start and end cell.
    Point startCellPos = new Point(startCell.getParentRow().indexOf(startCell),
        parentTable.indexOf(startCell.getParentRow()));
    Point endCellPos = new Point(endCell.getParentRow().indexOf(endCell), parentTable.indexOf(endCell.getParentRow()));

    // Create a range of cells to be merged based on these indices.
    // Inverse each index if the end cell is before the start cell.
    Rectangle mergeRange = new Rectangle(Math.min(startCellPos.x, endCellPos.y),
        Math.min(startCellPos.y, endCellPos.y),
        Math.abs(endCellPos.x - startCellPos.x) + 1, Math.abs(endCellPos.y - startCellPos.y) + 1);

    for (Row row : parentTable.getRows())
    {
        for (Cell cell : row.getCells())
        {
            Point currentPos = new Point(row.indexOf(cell), parentTable.indexOf(row));

            // Check if the current cell is inside our merge range, then merge it.
            if (mergeRange.contains(currentPos))
            {
                cell.getCellFormat().setHorizontalMerge(currentPos.x == mergeRange.getX() ? CellMerge.FIRST : CellMerge.PREVIOUS);

                cell.getCellFormat().setVerticalMerge(currentPos.y == mergeRange.getY() ? CellMerge.FIRST : CellMerge.PREVIOUS);
            }
        }
    }
}

Het volgende voorbeeld van code laat zien hoe een bereik van cellen te samenvoegen tussen twee gespecificeerde cellen:

// 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 with merged cells.docx");

Table table = doc.getFirstSection().getBody().getTables().get(0);

// We want to merge the range of cells found inbetween these two cells.
Cell cellStartRange = table.getRows().get(0).getCells().get(0);
Cell cellEndRange = table.getRows().get(1).getCells().get(1);

// Merge all the cells between the two specified cells into one.
mergeCells(cellStartRange, cellEndRange);
        
doc.save(getArtifactsDir() + "WorkingWithTables.MergeCellRange.docx");

Verticale en horizontale samengevoegde cellen in HTML-tabel

Zoals gezegd in vorige artikelen, een tabel in Microsoft Word is een reeks onafhankelijke rijen. Elke rij heeft een reeks cellen die onafhankelijk zijn van de cellen van andere rijen. In de Microsoft Word tabel is er geen object als een. .. .. .. .. 1e kolom. .. de set van de 1e cellen van elke rij in de tabel. Dit stelt gebruikers in staat om een tabel waarin, bijvoorbeeld, de 1e rij bestaat uit twee cellen 2cm en 1cm, en de 2e rij bestaat uit twee verschillende cellen 1cm en 2cm breed. En Aspose.Words steunt dit concept van tabellen.

Een tabel in HTML heeft een wezenlijk andere structuur: elke rij heeft hetzelfde aantal cellen en (het is belangrijk voor de taak) elke cel heeft de breedte van de overeenkomstige kolom, hetzelfde voor alle cellen in één kolom. Dus als HorizontalMerge en VerticalMerge retour een onjuiste waarde, gebruik het volgende code voorbeeld:

// 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 with merged cells.docx");

SpanVisitor visitor = new SpanVisitor(doc);
doc.accept(visitor);

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-Java.git.
/// <summary>
/// Helper class that contains collection of rowinfo for each row.
/// </summary>
public static class TableInfo
{
    public ArrayList<RowInfo> getRows() { return mRows; }

    private ArrayList<RowInfo> mRows = new ArrayList<>();
}

/// <summary>
/// Helper class that contains collection of cellinfo for each cell.
/// </summary>
public static class RowInfo
{
    public ArrayList<CellInfo> getCells() { return mCells; };

    private ArrayList<CellInfo> mCells = new ArrayList<>();
}

/// <summary>
/// Helper class that contains info about cell. currently here is only colspan and rowspan.
/// </summary>
public static class CellInfo
{
    public CellInfo(int colSpan, int rowSpan)
    {
        mColSpan = colSpan;
        mRowSpan = rowSpan;
    }

    public int getColSpan() { return mColSpan; };

    private  int mColSpan;
    public int getRowSpan() { return mRowSpan; };

    private  int mRowSpan;
}

public static class SpanVisitor extends DocumentVisitor
{
    /// <summary>
    /// Creates new SpanVisitor instance.
    /// </summary>
    /// <param name="doc">
    /// Is document which we should parse.
    /// </param>
    public SpanVisitor(Document doc) throws Exception {
        mWordTables = doc.getChildNodes(NodeType.TABLE, true);

        // We will parse HTML to determine the rowspan and colspan of each cell.
        ByteArrayOutputStream htmlStream = new ByteArrayOutputStream();

        HtmlSaveOptions options = new HtmlSaveOptions();
        {
            options.setImagesFolder(System.getProperty("java.io.tmpdir"));
        }

        doc.save(htmlStream, options);

        // Load HTML into the XML document.
        org.jsoup.nodes.Document document = Jsoup.parse(htmlStream.toString());

        // Get collection of tables in the HTML document.
        Elements tables = document.getElementsByTag("table");

        for (Element table : tables) {
            TableInfo tableInf = new TableInfo();

            // Get collection of rows in the table.
            Elements rows = table.getElementsByTag("tr");

            for (Element row : rows) {
                RowInfo rowInf = new RowInfo();

                // Get collection of cells.
                Elements cells = row.getElementsByTag("td");

                for (Element cell : cells) {
                    // Determine row span and colspan of the current cell.
                    String colSpanAttr = cell.attributes().get("colspan");
                    String rowSpanAttr = cell.attributes().get("rowspan");

                    int colSpan = StringUtils.isNotBlank(colSpanAttr) ? Integer.parseInt(colSpanAttr) : 0;
                    int rowSpan = StringUtils.isNotBlank(rowSpanAttr) ? Integer.parseInt(rowSpanAttr) : 0;

                    CellInfo cellInf = new CellInfo(colSpan, rowSpan);
                    rowInf.getCells().add(cellInf);
                }

                tableInf.getRows().add(rowInf);
            }

            mTables.add(tableInf);
        }
    }

    public int visitCellStart(Cell cell)
    {
        int tabIdx = mWordTables.indexOf(cell.getParentRow().getParentTable());
        int rowIdx = cell.getParentRow().getParentTable().indexOf(cell.getParentRow());
        int cellIdx = cell.getParentRow().indexOf(cell);

        int colSpan = 0;
        int rowSpan = 0;
        if (tabIdx < mTables.size() &&
            rowIdx < mTables.get(tabIdx).getRows().size() &&
            cellIdx < mTables.get(tabIdx).getRows().get(rowIdx).getCells().size())
        {
            colSpan = mTables.get(tabIdx).getRows().get(rowIdx).getCells().get(cellIdx).getColSpan();
            rowSpan = mTables.get(tabIdx).getRows().get(rowIdx).getCells().get(cellIdx).getRowSpan();
        }

        System.out.println(MessageFormat.format("{0}.{1}.{2} colspan={3}\t rowspan={4}", tabIdx, rowIdx, cellIdx, colSpan, rowSpan));

        return VisitorAction.CONTINUE;
    }

    private ArrayList<TableInfo> mTables = new ArrayList<>();
    private NodeCollection mWordTables;
}

Omzetten naar horizontaal Samengevoegde cellen

Soms is het niet mogelijk om te detecteren welke cellen worden samengevoegd omdat sommige nieuwere versies van Microsoft Word de mergevlaggen niet langer gebruiken wanneer cellen horizontaal worden samengevoegd. Maar voor situaties waarin cellen worden samengevoegd in een cel horizontaal door hun breedte met behulp van merge vlaggen, Aspose.Words levert de ConvertToHorizontallyMergedCells methode om cellen te converteren. Deze methode transformeert simpelweg de tabel en voegt zo nodig nieuwe cellen toe.

Het volgende voorbeeld van de code toont de bovenstaande methode in werking:

// 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 with merged cells.docx");

Table table = doc.getFirstSection().getBody().getTables().get(0);
// Now merged cells have appropriate merge flags.
table.convertToHorizontallyMergedCells();