Tabellenzellen zusammenführen

Manchmal erfordern bestimmte Zeilen in einer Tabelle eine Überschrift oder große Textblöcke, die die gesamte Breite der Tabelle einnehmen. Für die ordnungsgemäße Gestaltung der Tabelle kann der Benutzer mehrere Tabellenzellen zu einer zusammenführen. Aspose.Words unterstützt verbundene Zellen bei der Arbeit mit allen Eingabeformaten, einschließlich des Imports von HTML-Inhalten.

Wie man Tabellenzellen zusammenführt

In Aspose.Words werden zusammengeführte Zellen durch die folgenden Eigenschaften der Klasse CellFormat dargestellt:

• HorizontalMerge beschreibt, ob die Zelle Teil einer horizontalen Zusammenführung von Zellen ist
• VerticalMerge beschreibt, ob die Zelle Teil einer vertikalen Zusammenführung von Zellen ist

Die Werte dieser Eigenschaften bestimmen das Zusammenführungsverhalten von Zellen:

• Die erste Zelle in einer Folge zusammengeführter Zellen hat CellMerge.First
• Alle anschließend zusammengeführten Zellen haben CellMerge.Previous
• Eine Zelle, die nicht zusammengeführt wird, hat CellMerge.None

Manchmal werden beim Laden vorhandener Dokumentzellen in eine Tabelle diese zusammengeführt angezeigt. Es kann sich jedoch tatsächlich um eine lange Zelle handeln - manchmal exportiert Microsoft Word zusammengeführte Zellen auf diese Weise. Dies kann verwirrend sein, wenn versucht wird, mit einzelnen Zellen zu arbeiten, aber es scheint kein bestimmtes Muster zu geben, wann dies geschieht.

Überprüfen, ob eine Zelle zusammengeführt ist

Um zu überprüfen, ob eine Zelle Teil einer Sequenz zusammengeführter Zellen ist, überprüfen wir einfach die Eigenschaften HorizontalMerge und VerticalMerge.

Das folgende Codebeispiel zeigt, wie der horizontale und vertikale Zellzusammenführungstyp gedruckt wird:

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

Tabellenzellen zusammenführen, wenn DocumentBuilder verwendet wird

Um Zellen in einer Tabelle zusammenzuführen, die mit DocumentBuilder erstellt wurde, müssen Sie für jede Zelle, in der die Zusammenführung erwartet wird, den entsprechenden Zusammenführungstyp festlegen – zuerst CellMerge.First und dann CellMerge.Previous.

Außerdem müssen Sie daran denken, die Zusammenführungseinstellung für die Zellen zu löschen, für die keine Zusammenführung erforderlich ist. Dies kann erfolgen, indem Sie die erste Zelle ohne Zusammenführung auf CellMerge.None setzen. Geschieht dies nicht, werden alle Zellen in der Tabelle zusammengeführt.

Das folgende Codebeispiel zeigt, wie Sie eine Tabelle mit zwei Zeilen erstellen, in der die Zellen in der ersten Zeile horizontal zusammengeführt werden:

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

Das folgende Codebeispiel zeigt, wie Sie eine zweispaltige Tabelle erstellen, in der die Zellen in der ersten Spalte vertikal zusammengeführt werden:

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

Tabellenzellen in anderen Fällen zusammenführen

In anderen Situationen, in denen DocumentBuilder nicht verwendet wird, z. B. in einer vorhandenen Tabelle, ist das Zusammenführen von Zellen auf die vorherige Weise möglicherweise nicht so einfach. Stattdessen können wir die grundlegenden Vorgänge zum Anwenden von Zusammenführungseigenschaften auf Zellen in einer Methode zusammenfassen, die die Aufgabe erheblich vereinfacht. Diese Methode ähnelt der Merge-Automatisierungsmethode, die zum Zusammenführen eines Zellbereichs in einer Tabelle aufgerufen wird.

Der folgende Code führt die Tabellenzellen im angegebenen Bereich zusammen, beginnend mit der angegebenen Zelle und endend mit der Endzelle. In diesem Fall kann sich der Bereich über mehrere Zeilen oder Spalten erstrecken:

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

Das folgende Codebeispiel zeigt, wie ein Zellbereich zwischen zwei angegebenen Zellen zusammengeführt wird:

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

Vertikale und horizontale verbundene Zellen in HTML-Tabelle

Wie wir in früheren Artikeln gesagt haben, ist eine Tabelle in Microsoft Word eine Menge unabhängiger Zeilen. Jede Zeile enthält eine Reihe von Zellen, die von den Zellen anderer Zeilen unabhängig sind. Daher gibt es in der Microsoft Word -Tabelle kein Objekt wie eine “Spalte”, und “1. Spalte” ist so etwas wie “die Menge der 1. Zellen jeder Zeile in der Tabelle”. Auf diese Weise können Benutzer eine Tabelle erstellen, in der beispielsweise die 1. Zeile aus zwei Zellen besteht – 2 cm und 1 cm, und die 2. Zeile aus zwei verschiedenen Zellen besteht – 1 cm und 2 cm breit. Und Aspose.Words unterstützt dieses Konzept von Tabellen.

Eine Tabelle in HTML hat eine wesentlich andere Struktur: Jede Zeile hat die gleiche Anzahl von Zellen und (es ist wichtig für die Aufgabe) Jede Zelle hat die Breite der entsprechenden Spalte, die für alle Zellen in einer Spalte gleich ist. Wenn also HorizontalMerge und VerticalMerge einen falschen Wert zurückgeben, verwenden Sie das folgende Codebeispiel:

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

In horizontal verbundene Zellen konvertieren

Manchmal ist es nicht möglich zu erkennen, welche Zellen zusammengeführt werden, da einige neuere Versionen von Microsoft Word die Zusammenführungsflags nicht mehr verwenden, wenn Zellen horizontal zusammengeführt werden. Für Situationen, in denen Zellen mithilfe von Zusammenführungsflags horizontal nach ihrer Breite zu einer Zelle zusammengeführt werden, bietet Aspose.Words die ConvertToHorizontallyMergedCells -Methode zum Konvertieren von Zellen. Diese Methode transformiert einfach die Tabelle und fügt nach Bedarf neue Zellen hinzu.

Das folgende Codebeispiel zeigt die obige Methode in Betrieb:

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