Tabelcellen Samenvoegen

Soms vereisen bepaalde rijen in een tabel een kop of grote tekstblokken die de volledige breedte van de tabel in beslag nemen. Voor een goed ontwerp van de tabel kan de gebruiker meerdere tabelcellen samenvoegen tot één. Aspose.Words ondersteunt samengevoegde cellen bij het werken met alle Invoerindelingen, inclusief het importeren van HTML - Inhoud.

Hoe tabelcellen samenvoegen

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

• HorizontalMerge beschrijft of de cel deel uitmaakt van een horizontale samenvoeging van cellen
• VerticalMerge 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 heeft CellMerge.First
• Alle vervolgens samengevoegde cellen hebben CellMerge.Previous
• Een cel die niet is samengevoegd heeft CellMerge.None

Bij het laden van bestaande documentcellen in een tabel worden ze soms samengevoegd weergegeven. Het kan echter één lange cel zijn-soms exporteert Microsoft Word samengevoegde cellen op deze manier. Dit kan verwarrend zijn bij het proberen om met individuele cellen te werken, maar er lijkt geen bepaald patroon te zijn over wanneer dit gebeurt.

Controleer of de cel is samengevoegd

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

Het volgende codevoorbeeld laat zien hoe u het type horizontale en verticale cel samenvoegen kunt afdrukken:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Table with merged cells.docx");

auto table = System::ExplicitCast<Table>(doc->GetChild(NodeType::Table, 0, true));

for (const auto& row : System::IterateOver<Row>(table->get_Rows()))
{
    for (const auto& cell : System::IterateOver<Cell>(row->get_Cells()))
    {
        std::cout << PrintCellMergeType(cell) << std::endl;
    }
}

Samengevoegde cellen in een tabel

Als u cellen wilt samenvoegen in een tabel die met DocumentBuilder is gemaakt, moet u het juiste samenvoegtype instellen voor elke cel waar de samenvoeging wordt verwacht – eerst CellMerge.First en vervolgens CellMerge.Previous.

Vergeet ook niet om de samenvoeginstelling te wissen voor cellen waar geen samenvoeging vereist is – dit kan gedaan worden door de eerste niet-samenvoegcel in te stellen op CellMerge.None. Als dit niet gebeurt, worden alle cellen in de tabel samengevoegd.

Het volgende codevoorbeeld laat zien hoe u een tabel maakt met twee rijen waarin 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-C.git.
auto doc = MakeObject<Document>();
auto builder = MakeObject<DocumentBuilder>(doc);

builder->InsertCell();
builder->get_CellFormat()->set_HorizontalMerge(CellMerge::First);
builder->Write(u"Text in merged cells.");

builder->InsertCell();
// This cell is merged to the previous and should be empty.
builder->get_CellFormat()->set_HorizontalMerge(CellMerge::Previous);
builder->EndRow();

builder->InsertCell();
builder->get_CellFormat()->set_HorizontalMerge(CellMerge::None);
builder->Write(u"Text in one cell.");

builder->InsertCell();
builder->Write(u"Text in another cell.");
builder->EndRow();
builder->EndTable();

doc->Save(ArtifactsDir + u"WorkingWithTables.HorizontalMerge.docx");

Het volgende codevoorbeeld laat zien hoe u een tabel met twee kolommen maakt waarin de cellen in de eerste kolom verticaal worden samengevoegd:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>();
auto builder = MakeObject<DocumentBuilder>(doc);

builder->InsertCell();
builder->get_CellFormat()->set_VerticalMerge(CellMerge::First);
builder->Write(u"Text in merged cells.");

builder->InsertCell();
builder->get_CellFormat()->set_VerticalMerge(CellMerge::None);
builder->Write(u"Text in one cell");
builder->EndRow();

builder->InsertCell();
// This cell is vertically merged to the cell above and should be empty.
builder->get_CellFormat()->set_VerticalMerge(CellMerge::Previous);

builder->InsertCell();
builder->get_CellFormat()->set_VerticalMerge(CellMerge::None);
builder->Write(u"Text in another cell");
builder->EndRow();
builder->EndTable();

doc->Save(ArtifactsDir + u"WorkingWithTables.VerticalMerge.docx");

Tabelcellen samenvoegen in andere gevallen

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

De onderstaande code zal de tabelcellen in het opgegeven bereik samenvoegen, 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-C.git.
void MergeCells(SharedPtr<Cell> startCell, SharedPtr<Cell> endCell)
{
    SharedPtr<Table> parentTable = startCell->get_ParentRow()->get_ParentTable();

    // Find the row and cell indices for the start and end cell.
    System::Drawing::Point startCellPos(startCell->get_ParentRow()->IndexOf(startCell), parentTable->IndexOf(startCell->get_ParentRow()));
    System::Drawing::Point endCellPos(endCell->get_ParentRow()->IndexOf(endCell), parentTable->IndexOf(endCell->get_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.
    System::Drawing::Rectangle mergeRange(
        System::Math::Min(startCellPos.get_X(), endCellPos.get_X()), System::Math::Min(startCellPos.get_Y(), endCellPos.get_Y()),
        System::Math::Abs(endCellPos.get_X() - startCellPos.get_X()) + 1, System::Math::Abs(endCellPos.get_Y() - startCellPos.get_Y()) + 1);

    for (const auto& row : System::IterateOver<Row>(parentTable->get_Rows()))
    {
        for (const auto& cell : System::IterateOver<Cell>(row->get_Cells()))
        {
            System::Drawing::Point currentPos(row->IndexOf(cell), parentTable->IndexOf(row));

            // Check if the current cell is inside our merge range, then merge it.
            if (mergeRange.Contains(currentPos))
            {
                cell->get_CellFormat()->set_HorizontalMerge(currentPos.get_X() == mergeRange.get_X() ? CellMerge::First : CellMerge::Previous);

                cell->get_CellFormat()->set_VerticalMerge(currentPos.get_Y() == mergeRange.get_Y() ? CellMerge::First : CellMerge::Previous);
            }
        }
    }
}

Het volgende codevoorbeeld laat zien hoe een bereik van cellen tussen twee opgegeven cellen kan worden samengevoegd:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Table with merged cells.docx");

SharedPtr<Table> table = doc->get_FirstSection()->get_Body()->get_Tables()->idx_get(0);

// We want to merge the range of cells found inbetween these two cells.
SharedPtr<Cell> cellStartRange = table->get_Rows()->idx_get(0)->get_Cells()->idx_get(0);
SharedPtr<Cell> cellEndRange = table->get_Rows()->idx_get(1)->get_Cells()->idx_get(1);

// Merge all the cells between the two specified cells into one.
MergeCells(cellStartRange, cellEndRange);

doc->Save(ArtifactsDir + u"WorkingWithTables.MergeCellRange.docx");

Afhankelijk van de versie van het Framework dat u gebruikt, kunt u deze methode verfijnen door er een extensiemethode van te maken. In dit geval kunt u deze methode rechtstreeks op een cel aanroepen om een celbereik samen te voegen, zoals cell1.Merge(cell2).

Verticale en horizontale samengevoegde cellen in een tabel

Zoals we in eerdere artikelen hebben gezegd, is een tabel in Microsoft Word een verzameling onafhankelijke rijen. Elke rij heeft een set cellen die onafhankelijk zijn van de cellen van andere rijen. In de tabel Microsoft Word is er dus geen object als een “kolom”, en “1e kolom” is iets als “de verzameling van de 1e cellen van elke rij in de tabel”. Hierdoor kunnen gebruikers een tabel hebben 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 ondersteunt 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 een onjuiste waarde retourneren, gebruik dan het volgende codevoorbeeld:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Table with merged cells.docx");

auto visitor = MakeObject<WorkingWithTables::SpanVisitor>(doc);
doc->Accept(visitor);

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
/// <summary>
/// Helper class that contains collection of rowinfo for each row.
/// </summary>
class TableInfo : public System::Object
{
public:
    SharedPtr<System::Collections::Generic::List<SharedPtr<WorkingWithTables::RowInfo>>> get_Rows()
    {
        return mRows;
    }

    TableInfo() : mRows(MakeObject<System::Collections::Generic::List<SharedPtr<WorkingWithTables::RowInfo>>>())
    {
    }

private:
    SharedPtr<System::Collections::Generic::List<SharedPtr<WorkingWithTables::RowInfo>>> mRows;
};

/// <summary>
/// Helper class that contains collection of cellinfo for each cell.
/// </summary>
class RowInfo : public System::Object
{
public:
    SharedPtr<System::Collections::Generic::List<SharedPtr<WorkingWithTables::CellInfo>>> get_Cells()
    {
        return mCells;
    }

    RowInfo() : mCells(MakeObject<System::Collections::Generic::List<SharedPtr<WorkingWithTables::CellInfo>>>())
    {
    }

private:
    SharedPtr<System::Collections::Generic::List<SharedPtr<WorkingWithTables::CellInfo>>> mCells;
};

/// <summary>
/// Helper class that contains info about cell. currently here is only colspan and rowspan.
/// </summary>
class CellInfo : public System::Object
{
public:
    int get_ColSpan()
    {
        return pr_ColSpan;
    }

    int get_RowSpan()
    {
        return pr_RowSpan;
    }

    CellInfo(int colSpan, int rowSpan) : pr_ColSpan(0), pr_RowSpan(0)
    {
        pr_ColSpan = colSpan;
        pr_RowSpan = rowSpan;
    }

private:
    int pr_ColSpan;
    int pr_RowSpan;
};

class SpanVisitor : public DocumentVisitor
{
public:
    /// <summary>
    /// Creates new SpanVisitor instance.
    /// </summary>
    /// <param name="doc">
    /// Is document which we should parse.
    /// </param>
    SpanVisitor(SharedPtr<Document> doc) : mTables(MakeObject<System::Collections::Generic::List<SharedPtr<WorkingWithTables::TableInfo>>>())
    {
        mWordTables = doc->GetChildNodes(NodeType::Table, true);

        // We will parse HTML to determine the rowspan and colspan of each cell.
        auto htmlStream = MakeObject<System::IO::MemoryStream>();

        auto options = MakeObject<Aspose::Words::Saving::HtmlSaveOptions>();
        options->set_ImagesFolder(System::IO::Path::GetTempPath());

        doc->Save(htmlStream, options);

        // Load HTML into the XML document.
        auto xmlDoc = MakeObject<System::Xml::XmlDocument>();
        htmlStream->set_Position(0);
        xmlDoc->Load(htmlStream);

        // Get collection of tables in the HTML document.
        SharedPtr<System::Xml::XmlNodeList> tables = xmlDoc->get_DocumentElement()->GetElementsByTagName(u"table");

        for (const auto& table : System::IterateOver(tables))
        {
            auto tableInf = MakeObject<WorkingWithTables::TableInfo>();
            // Get collection of rows in the table.
            SharedPtr<System::Xml::XmlNodeList> rows = table->SelectNodes(u"tr");

            for (const auto& row : System::IterateOver(rows))
            {
                auto rowInf = MakeObject<WorkingWithTables::RowInfo>();
                // Get collection of cells.
                SharedPtr<System::Xml::XmlNodeList> cells = row->SelectNodes(u"td");

                for (const auto& cell : System::IterateOver(cells))
                {
                    // Determine row span and colspan of the current cell.
                    SharedPtr<System::Xml::XmlAttribute> colSpanAttr = cell->get_Attributes()->idx_get(u"colspan");
                    SharedPtr<System::Xml::XmlAttribute> rowSpanAttr = cell->get_Attributes()->idx_get(u"rowspan");

                    int colSpan = colSpanAttr == nullptr ? 0 : System::Int32::Parse(colSpanAttr->get_Value());
                    int rowSpan = rowSpanAttr == nullptr ? 0 : System::Int32::Parse(rowSpanAttr->get_Value());

                    auto cellInf = MakeObject<WorkingWithTables::CellInfo>(colSpan, rowSpan);
                    rowInf->get_Cells()->Add(cellInf);
                }

                tableInf->get_Rows()->Add(rowInf);
            }

            mTables->Add(tableInf);
        }
    }

    VisitorAction VisitCellStart(SharedPtr<Cell> cell) override
    {
        int tabIdx = mWordTables->IndexOf(cell->get_ParentRow()->get_ParentTable());
        int rowIdx = cell->get_ParentRow()->get_ParentTable()->IndexOf(cell->get_ParentRow());
        int cellIdx = cell->get_ParentRow()->IndexOf(cell);

        int colSpan = 0;
        int rowSpan = 0;
        if (tabIdx < mTables->get_Count() && rowIdx < mTables->idx_get(tabIdx)->get_Rows()->get_Count() &&
            cellIdx < mTables->idx_get(tabIdx)->get_Rows()->idx_get(rowIdx)->get_Cells()->get_Count())
        {
            colSpan = mTables->idx_get(tabIdx)->get_Rows()->idx_get(rowIdx)->get_Cells()->idx_get(cellIdx)->get_ColSpan();
            rowSpan = mTables->idx_get(tabIdx)->get_Rows()->idx_get(rowIdx)->get_Cells()->idx_get(cellIdx)->get_RowSpan();
        }

        std::cout << tabIdx << "." << rowIdx << "." << cellIdx << " colspan=" << colSpan << "\t rowspan=" << rowSpan << std::endl;

        return VisitorAction::Continue;
    }

private:
    SharedPtr<System::Collections::Generic::List<SharedPtr<WorkingWithTables::TableInfo>>> mTables;
    SharedPtr<NodeCollection> mWordTables;
};

Converteren naar horizontaal samengevoegde cellen

Soms is het niet mogelijk om te detecteren welke cellen zijn samengevoegd omdat sommige nieuwere versies van Microsoft Word de samenvoegvlaggen niet meer gebruiken wanneer cellen horizontaal worden samengevoegd. Maar voor situaties waarin cellen horizontaal worden samengevoegd in een cel door hun breedte met behulp van samenvoegvlaggen, biedt Aspose.Words de ConvertToHorizontallyMergedCells methode om cellen te converteren. Deze methode transformeert eenvoudig de tabel en voegt nieuwe cellen toe als dat nodig is.

Het volgende codevoorbeeld toont de bovenstaande methode in werking:

// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
auto doc = MakeObject<Document>(MyDir + u"Table with merged cells.docx");

SharedPtr<Table> table = doc->get_FirstSection()->get_Body()->get_Tables()->idx_get(0);
// Now merged cells have appropriate merge flags.
table->ConvertToHorizontallyMergedCells();