Saamvlans Tabel Selle

Soms vereis sekere rye in’n tabel’n kop of groot blokke teks wat die volle breedte van die tabel beslaan. Vir behoorlike ontwerp van die tabel, kan die gebruiker verskeie tabel selle saamvoeg in een. Aspose.Words ondersteun saamgesmelte selle wanneer jy met alle invoerformate werk, insluitend die invoer van HTML inhoud.

Hoe Om Tabel Selle Saam Te Voeg

In Aspose.Words word saamgesmelte selle verteenwoordig deur die volgende eienskappe van die CellFormat klas:

• HorizontalMerge wat beskryf of die sel deel is van’n horisontale samesmelting van selle
• VerticalMerge wat beskryf of die sel deel is van’n vertikale samesmelting van selle

Die waardes van hierdie eienskappe bepaal die samesmelting gedrag van selle:

• Die eerste sel in’n reeks saamgesmelte selle sal CellMerge.Firsthê
• Enige latere saamgesmelte selle sal CellMerge.Previoushê
• ‘n sel wat nie saamgevoeg is nie, sal CellMerge.Nonehê

Soms, wanneer die laai van bestaande dokument selle in’n tabel, sal hulle saamgesmelt verskyn. Dit kan egter eintlik een lang sel wees – soms voer Microsoft Word saamgesmelte selle op hierdie manier uit. Dit kan verwarrend wees wanneer jy met individuele selle probeer werk, maar dit lyk nie of daar enige spesifieke patroon is wanneer dit gebeur nie.

Kontroleer of’n Sel Saamgesmelt is

Om te kyk of’n sel deel is van’n reeks saamgesmelte selle, kyk ons eenvoudig na die eienskappe HorizontalMerge en VerticalMerge.

Die volgende kode voorbeeld toon hoe om die horisontale en vertikale sel samesmelting tipe druk:

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

Voeg Tabelselle Saam Wanneer DocumentBuilderGebruik Word

Om selle saam te voeg in’n tabel wat met die DocumentBuilder geskep is, moet jy die toepaslike samesmeltingstipe stel vir elke sel waar die samesmelting verwag word – eers CellMerge.First en dan CellMerge.Previous.

Jy moet ook onthou om die samesmelting instelling vir die selle waar geen samesmelting nodig is skoon te maak - dit kan gedoen word deur die eerste nie-samesmelting sel te stel om CellMerge.None. As dit nie gedoen word nie, sal alle selle in die tabel saamgesmelt word.

Die volgende kode voorbeeld toon hoe om’n tabel met twee rye waar die selle in die eerste ry horisontaal saamgesmelt skep:

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

Die volgende kode voorbeeld toon hoe om’n twee-kolom tabel te skep waar die selle in die eerste kolom vertikaal saamgesmelt:

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

Voeg Tabel Selle saam In ander Gevalle

In ander situasies waar die DocumentBuilder nie gebruik word nie, soos in’n bestaande tabel, kan die samesmelting van selle op die vorige manier nie so maklik wees nie. In plaas daarvan kan ons die basiese bedrywighede wat betrokke is by die toepassing van samesmelting eienskappe aan selle in’n metode wat die taak baie makliker maak. Hierdie metode is soortgelyk aan die Samesmelting outomatisering metode, wat genoem word om’n reeks selle in’n tabel saam te smelt.

Die kode hieronder sal die tabel selle in die gespesifiseerde reeks saamvoeg, begin by die gegewe sel en eindig by die einde sel. In hierdie geval kan die reeks oor verskeie rye of kolomme strek:

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

Die volgende kode voorbeeld toon hoe om’n reeks selle tussen twee gespesifiseerde selle saam te smelt:

// 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 En Horisontale Saamgesmelte Selle in HTML Tabel

Soos ons in vorige artikels gesê het, is’n tabel in Microsoft Word ‘n stel onafhanklike rye. Elke ry het’n stel selle wat onafhanklik is van die selle van ander rye. In die Microsoft Word tabel is daar dus nie so’n voorwerp soos’n “kolom” nie, en “1ste kolom” is iets soos “die versameling van die 1ste selle van elke ry in die tabel”. Dit laat gebruikers toe om’n tabel te hê waarin byvoorbeeld die 1ste ry bestaan uit twee selle – 2cm en 1cm, en die 2de ry bestaan uit twee verskillende selle – 1cm en 2cm breed. En Aspose.Words ondersteun hierdie konsep van tabelle.

‘n tabel in HTML het’n wesenlik ander struktuur: elke ry het dieselfde aantal selle en (dit is belangrik vir die taak) elke sel het die breedte van die ooreenstemmende kolom, dieselfde vir alle selle in een kolom. So as HorizontalMerge en VerticalMerge ‘n verkeerde waarde terug te keer, gebruik die volgende kode 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;
}

Skakel Om Na Horisontaal Saamgesmelte Selle

Soms is dit nie moontlik om te ontdek watter selle saamgesmelt word nie omdat sommige nuwer weergawes van Microsoft Word nie meer die samesmeltingsvlae gebruik wanneer selle horisontaal saamgesmelt word nie. Maar vir situasies waar selle horisontaal in’n sel saamgevoeg word deur hul breedte met behulp van samesmeltingsvlae, bied Aspose.Words die ConvertToHorizontallyMergedCells metode om selle te omskep. Hierdie metode verander eenvoudig die tabel en voeg nuwe selle by soos nodig.

Die volgende kode voorbeeld toon die bogenoemde metode 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();