Scal komórki tabeli

Czasami niektóre wiersze tabeli wymagają nagłówka lub dużych bloków tekstu zajmujących całą szerokość tabeli. Dla prawidłowego zaprojektowania tabeli użytkownik może połączyć kilka komórek tabeli w jedną. Aspose.Words obsługuje scalone komórki podczas pracy ze wszystkimi formatami wejściowymi, w tym podczas importowania treści HTML.

Jak scalić komórki tabeli

W Aspose.Words połączone komórki są reprezentowane przez następujące właściwości klasy CellFormat:

• HorizontalMerge, który opisuje, czy komórka jest częścią poziomego scalania komórek
• VerticalMerge, który opisuje, czy komórka jest częścią pionowego scalania komórek

Wartości tych właściwości określają zachowanie komórek podczas scalania:

• Pierwsza komórka w sekwencji połączonych komórek będzie miała CellMerge.First
• Wszystkie później połączone komórki będą miały CellMerge.Previous
• Komórka, która nie jest scalona, będzie miała CellMerge.None

Czasami podczas ładowania istniejących komórek dokumentów do tabeli będą one wyświetlane jako scalone. Jednak w rzeczywistości może to być jedna długa komórka – czasami Microsoft Word eksportuje w ten sposób scalone komórki. Może to być mylące przy próbie pracy z pojedynczymi komórkami, ale wydaje się, że nie ma żadnego szczególnego wzorca określającego, kiedy to się dzieje.

Sprawdź, czy komórka jest scalona

Aby sprawdzić, czy komórka jest częścią sekwencji połączonych komórek, po prostu sprawdzamy właściwości HorizontalMerge i VerticalMerge.

Poniższy przykład kodu pokazuje, jak wydrukować typ scalania komórek w poziomie i pionie:

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

Możesz pobrać przykładowy plik tego przykładu z Aspose.Words GitHub.

Scal komórki tabeli podczas korzystania z narzędzia DocumentBuilder

Aby scalić komórki w tabeli utworzonej za pomocą DocumentBuilder, należy ustawić odpowiedni typ scalania dla każdej komórki, w której ma nastąpić scalanie – najpierw CellMerge.First, a następnie CellMerge.Previous.

Należy także pamiętać o wyczyszczeniu ustawienia scalania dla tych komórek, w których nie jest wymagane scalanie – można to zrobić, ustawiając pierwszą komórkę niescaloną na CellMerge.None. Jeśli nie zostanie to zrobione, wszystkie komórki w tabeli zostaną scalone.

Poniższy przykład kodu pokazuje, jak utworzyć tabelę z dwoma wierszami, w której komórki pierwszego wiersza są scalone w poziomie:

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

Poniższy przykład kodu pokazuje, jak utworzyć dwukolumnową tabelę, w której komórki w pierwszej kolumnie są scalone w pionie:

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

Scal komórki tabeli w innych przypadkach

W innych sytuacjach, w których nie jest używany DocumentBuilder, na przykład w istniejącej tabeli, łączenie komórek w poprzedni sposób może nie być takie proste. Zamiast tego możemy opakować podstawowe operacje związane z zastosowaniem właściwości scalania do komórek w metodę, która znacznie ułatwia to zadanie. Ta metoda jest podobna do metody automatyzacji scalania, która jest wywoływana w celu scalania zakresu komórek w tabeli.

Poniższy kod połączy komórki tabeli w określonym zakresie, zaczynając od podanej komórki i kończąc na komórce końcowej. W takim przypadku zakres może obejmować wiele wierszy lub kolumn:

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

Poniższy przykład kodu pokazuje, jak scalić zakres komórek między dwiema określonymi komórkami:

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

Możesz pobrać przykładowy plik tego przykładu z Aspose.Words GitHub.

W zależności od używanej wersji .NET Framework możesz udoskonalić tę metodę, przekształcając ją w metodę rozszerzenia. W takim przypadku możesz wywołać tę metodę bezpośrednio w komórce, aby scalić zakres komórek, na przykład cell1.Merge(cell2).

Pionowe i poziome scalone komórki w tabeli HTML

Jak powiedzieliśmy w poprzednich artykułach, tabela w Microsoft Word to zbiór niezależnych wierszy. Każdy wiersz zawiera zestaw komórek niezależnych od komórek w innych wierszach. Zatem w tabeli Microsoft Word nie ma takiego obiektu jak “kolumna”, a “1. kolumna” to coś w rodzaju “zbioru pierwszych komórek każdego wiersza tabeli”. Dzięki temu użytkownicy mogą mieć tabelę, w której np. 1. rząd składa się z dwóch komórek – 2cm i 1cm, a 2. rząd składa się z dwóch różnych komórek – 1cm i 2cm szerokości. Aspose.Words obsługuje tę koncepcję tabel.

Tabela w HTML ma zasadniczo inną strukturę: każdy wiersz ma tę samą liczbę komórek i (jest to ważne dla zadania) każda komórka ma szerokość odpowiadającej jej kolumny, taką samą dla wszystkich komórek w jednej kolumnie. Jeśli więc HorizontalMerge i VerticalMerge zwrócą niepoprawną wartość, użyj następującego przykładowego kodu:

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

Możesz pobrać przykładowy plik tego przykładu z Aspose.Words GitHub.

Konwertuj na komórki połączone poziomo

Czasami nie jest możliwe wykrycie, które komórki zostały scalone, ponieważ niektóre nowsze wersje Microsoft Word nie używają już flag scalania, gdy komórki są łączone w poziomie. Jednak w sytuacjach, gdy komórki są łączone w komórkę poziomo według ich szerokości przy użyciu flag scalania, Aspose.Words udostępnia metodę ConvertToHorizontallyMergedCells do konwersji komórek. Ta metoda po prostu przekształca tabelę i w razie potrzeby dodaje nowe komórki.

Poniższy przykład kodu ilustruje działanie powyższej metody:

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