Sloučit stolní buňky

Někdy některé řádky v tabulce vyžadují nadpis nebo velké bloky textu, které zabírají celou šířku tabulky. Pro řádný návrh tabulky může uživatel sloučit několik stolních buněk do jedné. Aspose.Words podporuje sloučené buňky při práci se všemi vstupními formáty, včetně importu HTML obsahu.

Jak sloučit stolní buňky

In Aspose.Words, sloučené buňky jsou zastoupeny následujícími vlastnostmi: CellFormat třída:

• HorizontalMerge která popisuje, zda je buňka součástí horizontálního sloučení buněk
• VerticalMerge která popisuje, zda je buňka součástí vertikálního sloučení buněk

Hodnoty těchto vlastností určují slučovací chování buněk:

• První buňka v řadě sloučených buněk bude mít CellMerge.First
• Všechny následně sloučené buňky budou mít CellMerge.Previous
• Buňka, která není sloučena, bude mít CellMerge.None

Někdy se při načítání stávajících dokumentových buněk do tabulky objeví spojení. Nicméně, to může být ve skutečnosti jedna dlouhá buňka někdy Microsoft Word export takto spojil buňky. To může být matoucí při pokusu o práci s jednotlivými buňkami, ale nezdá se, že by tam byl žádný konkrétní vzorec, pokud se to stane.

Zkontrolujte, zda je buňka Merged

Chcete-li zjistit, zda je buňka součástí sekvence sloučených buněk, stačí zkontrolovat HorizontalMerge a VerticalMerge vlastnosti.

Následující příklad kódu ukazuje, jak tisknout horizontální a vertikální typ sloučení buňky:

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

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

foreach (Row row in table.Rows)
{
    foreach (Cell cell in row.Cells)
    {
        Console.WriteLine(PrintCellMergeType(cell));
    }
}

Soubor vzorku tohoto příkladu si můžete stáhnout z Aspose.Words GitHub.

Sloučit stolní buňky při použití dokumentu

Sloučit buňky v tabulce vytvořené s DocumentBuilder, Musíte nastavit vhodný typ sloučení pro každou buňku, kde se očekává sloučení, nejprve CellMerge.First a pak CellMerge.Previous.

Také, musíte nezapomeňte vyčistit nastavení sloučení pro ty buňky, kde není požadováno sloučení to lze provést nastavením první ne-sloučit buňky na CellMerge.None. Pokud tomu tak není, všechny buňky v tabulce budou sloučeny.

Následující příklad kódu ukazuje, jak vytvořit tabulku se dvěma řádky, kde jsou buňky v prvním řádku sloučeny vodorovně:

// 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.InsertCell();
builder.CellFormat.HorizontalMerge = CellMerge.First;
builder.Write("Text in merged cells.");

builder.InsertCell();
// This cell is merged to the previous and should be empty.
builder.CellFormat.HorizontalMerge = CellMerge.Previous;
builder.EndRow();

builder.InsertCell();
builder.CellFormat.HorizontalMerge = CellMerge.None;
builder.Write("Text in one cell.");

builder.InsertCell();
builder.Write("Text in another cell.");
builder.EndRow();
builder.EndTable();
            
doc.Save(ArtifactsDir + "WorkingWithTables.HorizontalMerge.docx");

Následující příklad kódu ukazuje, jak vytvořit tabulku dvou sloupců, kde jsou buňky v prvním sloupci vertikálně sloučeny:

// 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.InsertCell();
builder.CellFormat.VerticalMerge = CellMerge.First;
builder.Write("Text in merged cells.");

builder.InsertCell();
builder.CellFormat.VerticalMerge = 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.CellFormat.VerticalMerge = CellMerge.Previous;

builder.InsertCell();
builder.CellFormat.VerticalMerge = CellMerge.None;
builder.Write("Text in another cell");
builder.EndRow();
builder.EndTable();
            
doc.Save(ArtifactsDir + "WorkingWithTables.VerticalMerge.docx");

Sloučit stolní buňky v jiných případech

V jiných situacích, kdy DocumentBuilder není používán, jako například ve stávající tabulce, slučování buněk předchozí cestou nemusí být tak snadné. Místo toho můžeme zabalit základní operace, které se podílejí na aplikaci slučovacích vlastností na buňky metodou, která tento úkol mnohem usnadňuje. Tato metoda je podobná metodě automatizace Sloučení, která se volá ke sloučení řady buněk v tabulce.

Níže uvedený kód sloučí buňky tabulky ve stanoveném rozsahu, počínaje danou buňkou a končí na konci buňky. V tomto případě může rozsah rozdělit více řádků nebo sloupců:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-.NET.git.
internal void MergeCells(Cell startCell, Cell endCell)
{
    Table parentTable = startCell.ParentRow.ParentTable;

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

    // 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.X),
        Math.Min(startCellPos.Y, endCellPos.Y),
        Math.Abs(endCellPos.X - startCellPos.X) + 1, Math.Abs(endCellPos.Y - startCellPos.Y) + 1);

    foreach (Row row in parentTable.Rows)
    {
        foreach (Cell cell in row.Cells)
        {
            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.CellFormat.HorizontalMerge = currentPos.X == mergeRange.X ? CellMerge.First : CellMerge.Previous;

                cell.CellFormat.VerticalMerge = currentPos.Y == mergeRange.Y ? CellMerge.First : CellMerge.Previous;
            }
        }
    }
}

Následující příklad kódu ukazuje, jak sloučit rozsah buněk mezi dvěma specifikovanými buňkami:

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

Table table = doc.FirstSection.Body.Tables[0];

// We want to merge the range of cells found inbetween these two cells.
Cell cellStartRange = table.Rows[0].Cells[0];
Cell cellEndRange = table.Rows[1].Cells[1];

// Merge all the cells between the two specified cells into one.
MergeCells(cellStartRange, cellEndRange);
            
doc.Save(ArtifactsDir + "WorkingWithTables.MergeCellRange.docx");

Soubor vzorku tohoto příkladu si můžete stáhnout z Aspose.Words GitHub.

V závislosti na verzi .NET Framework používáte, možná budete chtít tuto metodu vylepšit přeměnou na metodu rozšíření. V tomto případě můžete tuto metodu volat přímo na buňku, abyste sloučili řadu buněk, například cell1.Merge(cell2).

Vertikální a horizontální Mergované buňky v HTML tabulce

Jak jsme řekli v předchozích článcích, tabulka v Microsoft Word je soubor nezávislých řádků. Každá řada má sadu buněk, které jsou nezávislé na buňkách jiných řádků. Proto v Microsoft Word Tabulka neexistuje žádný takový předmět, jako je sloupec To umožňuje uživatelům mít tabulku, v níž například 1. řádek se skládá ze dvou buněk 2cm a 1cm, a 2. řádek se skládá ze dvou různých buněk 1cm a 2cm široké. A Aspose.Words podporuje tento koncept tabulek.

Tabulka v HTML má v podstatě jinou strukturu: každý řádek má stejný počet buněk a (je to důležité pro úkol) každá buňka má šířku odpovídajícího sloupce, stejný pro všechny buňky v jednom sloupci. Takže pokud HorizontalMerge a VerticalMerge vrátit nesprávnou hodnotu, použijte následující příklad kódu:

// 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 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-.NET.git.
/// <summary>
/// Helper class that contains collection of rowinfo for each row.
/// </summary>
public class TableInfo
{
    public List<RowInfo> Rows { get; } = new List<RowInfo>();
}

/// <summary>
/// Helper class that contains collection of cellinfo for each cell.
/// </summary>
public class RowInfo
{
    public List<CellInfo> Cells { get; } = new List<CellInfo>();
}

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

    public int ColSpan { get; }
    public int RowSpan { get; }
}

public class SpanVisitor : DocumentVisitor
{
    /// <summary>
    /// Creates new SpanVisitor instance.
    /// </summary>
    /// <param name="doc">
    /// Is document which we should parse.
    /// </param>
    public SpanVisitor(Document doc)
    {
        mWordTables = doc.GetChildNodes(NodeType.Table, true);

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

        Aspose.Words.Saving.HtmlSaveOptions options = new Aspose.Words.Saving.HtmlSaveOptions
        {
            ImagesFolder = Path.GetTempPath()
        };

        doc.Save(htmlStream, options);

        // Load HTML into the XML document.
        XmlDocument xmlDoc = new XmlDocument();
        htmlStream.Position = 0;
        xmlDoc.Load(htmlStream);

        // Get collection of tables in the HTML document.
        XmlNodeList tables = xmlDoc.DocumentElement.GetElementsByTagName("table");

        foreach (XmlNode table in tables)
        {
            TableInfo tableInf = new TableInfo();
            // Get collection of rows in the table.
            XmlNodeList rows = table.SelectNodes("tr");

            foreach (XmlNode row in rows)
            {
                RowInfo rowInf = new RowInfo();
                // Get collection of cells.
                XmlNodeList cells = row.SelectNodes("td");

                foreach (XmlNode cell in cells)
                {
                    // Determine row span and colspan of the current cell.
                    XmlAttribute colSpanAttr = cell.Attributes["colspan"];
                    XmlAttribute rowSpanAttr = cell.Attributes["rowspan"];

                    int colSpan = colSpanAttr == null ? 0 : int.Parse(colSpanAttr.Value);
                    int rowSpan = rowSpanAttr == null ? 0 : int.Parse(rowSpanAttr.Value);

                    CellInfo cellInf = new CellInfo(colSpan, rowSpan);
                    rowInf.Cells.Add(cellInf);
                }

                tableInf.Rows.Add(rowInf);
            }

            mTables.Add(tableInf);
        }
    }

    public override VisitorAction VisitCellStart(Cell cell)
    {
        int tabIdx = mWordTables.IndexOf(cell.ParentRow.ParentTable);
        int rowIdx = cell.ParentRow.ParentTable.IndexOf(cell.ParentRow);
        int cellIdx = cell.ParentRow.IndexOf(cell);

        int colSpan = 0;
        int rowSpan = 0;
        if (tabIdx < mTables.Count &&
            rowIdx < mTables[tabIdx].Rows.Count &&
            cellIdx < mTables[tabIdx].Rows[rowIdx].Cells.Count)
        {
            colSpan = mTables[tabIdx].Rows[rowIdx].Cells[cellIdx].ColSpan;
            rowSpan = mTables[tabIdx].Rows[rowIdx].Cells[cellIdx].RowSpan;
        }

        Console.WriteLine("{0}.{1}.{2} colspan={3}\t rowspan={4}", tabIdx, rowIdx, cellIdx, colSpan, rowSpan);

        return VisitorAction.Continue;
    }

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

Soubor vzorku tohoto příkladu si můžete stáhnout z Aspose.Words GitHub.

Převést na horizontálně Promísené buňky

Někdy není možné zjistit, které buňky jsou sloučeny, protože některé novější verze Microsoft Word již nepoužívat vlajky sloučení, když jsou buňky sloučeny horizontálně. Ale pro situace, kdy jsou buňky sloučeny do buňky horizontálně podle jejich šířky pomocí flagů spojení, Aspose.Words poskytuje ConvertToHorizontallyMergedCells metoda přeměny buněk. Tato metoda jednoduše transformuje tabulku a přidává nové buňky podle potřeby.

Následující příklad kódu ukazuje výše uvedenou metodu v provozu:

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

Table table = doc.FirstSection.Body.Tables[0];
// Now merged cells have appropriate merge flags.
table.ConvertToHorizontallyMergedCells();