Unisci celle tabella

A volte alcune righe di una tabella richiedono un’intestazione o grandi blocchi di testo che occupano l’intera larghezza della tabella. Per una corretta progettazione della tabella, l’utente può unire più celle della tabella in una sola. Aspose.Words supporta le celle unite quando si lavora con tutti i formati di input, inclusa l’importazione di contenuto HTML.

Come unire le celle della tabella

In Aspose.Words, le celle unite sono rappresentate dalle seguenti proprietà della classe CellFormat:

• HorizontalMerge che descrive se la cella fa parte di un’unione orizzontale di celle
• VerticalMerge che descrive se la cella fa parte di un’unione verticale di celle

I valori di queste proprietà determinano il comportamento di unione delle celle:

• La prima cella di una sequenza di celle unite avrà CellMerge.First
• Qualsiasi cella successivamente unita avrà CellMerge.Previous
• Una cella che non è unita avrà CellMerge.None

A volte, quando si caricano celle di documento esistenti in una tabella, appariranno unite. Tuttavia, può effettivamente essere una cella lunga-a volte Microsoft Word esporta celle unite in questo modo. Questo può essere fonte di confusione quando si tenta di lavorare con le singole cellule, ma non sembra esserci alcun modello particolare su quando ciò accade.

Controlla se la cella è unita

Per verificare se una cella fa parte di una sequenza di celle unite, controlliamo semplicemente le proprietà HorizontalMerge e VerticalMerge.

L’esempio di codice seguente mostra come stampare il tipo di unione di celle orizzontale e verticale:

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

Celle unite in una tabella

Per unire le celle in una tabella creata con DocumentBuilder, è necessario impostare il tipo di unione appropriato per ogni cella in cui è prevista l’unione, prima CellMerge.First e poi CellMerge.Previous.

Inoltre, è necessario ricordarsi di deselezionare l’impostazione di unione per quelle celle in cui non è richiesta alcuna unione: ciò può essere fatto impostando la prima cella non unione su CellMerge.None. Se ciò non viene fatto, tutte le celle della tabella verranno unite.

L’esempio di codice seguente mostra come creare una tabella con due righe in cui le celle della prima riga vengono unite orizzontalmente:

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

L’esempio di codice seguente mostra come creare una tabella a due colonne in cui le celle della prima colonna vengono unite verticalmente:

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

Unire le celle della tabella in altri casi

In altre situazioni in cui DocumentBuilder non viene utilizzato, ad esempio in una tabella esistente, l’unione delle celle nel modo precedente potrebbe non essere così semplice. Invece, possiamo avvolgere le operazioni di base coinvolte nell’applicazione delle proprietà di unione alle celle in un metodo che rende l’attività molto più semplice. Questo metodo è simile al metodo di automazione dell’unione, che viene chiamato per unire un intervallo di celle in una tabella.

Il codice seguente unirà le celle della tabella nell’intervallo specificato, iniziando dalla cella specificata e terminando alla cella finale. In questo caso, l’intervallo può estendersi su più righe o colonne:

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

L’esempio di codice seguente mostra come unire un intervallo di celle tra due celle specificate:

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

A seconda della versione del framework che si sta utilizzando, è possibile perfezionare questo metodo trasformandolo in un metodo di estensione. In questo caso, è possibile chiamare questo metodo direttamente su una cella per unire un intervallo di celle, ad esempio cell1.Merge(cell2).

Celle unite verticali e orizzontali in una tabella

Come abbiamo detto negli articoli precedenti, una tabella in Microsoft Word è un insieme di righe indipendenti. Ogni riga ha un insieme di celle indipendenti dalle celle di altre righe. Quindi, nella tabella Microsoft Wordnon esiste un oggetto come una “colonna” e “1st column” è qualcosa come “l’insieme delle celle 1 st di ogni riga nella tabella”. Ciò consente agli utenti di avere una tabella in cui, ad esempio, la riga 1st è composta da due celle – 2cm e 1cm, e la riga 2nd è composta da due celle diverse – 1cm e 2cm di larghezza. E Aspose.Words supporta questo concetto di tabelle.

Una tabella in HTML ha una struttura essenzialmente diversa: ogni riga ha lo stesso numero di celle e (è importante per l’attività) ogni cella ha la larghezza della colonna corrispondente, la stessa per tutte le celle in una colonna. Quindi, se HorizontalMerge e VerticalMerge restituiscono un valore errato, utilizzare il seguente esempio di codice:

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

Converti in celle unite orizzontalmente

A volte non è possibile rilevare quali celle vengono unite perché alcune versioni più recenti di Microsoft Word non utilizzano più i flag di unione quando le celle vengono unite orizzontalmente. Ma per le situazioni in cui le celle vengono unite in una cella orizzontalmente per la loro larghezza usando i flag di unione, Aspose.Words fornisce il metodo ConvertToHorizontallyMergedCells per convertire le celle. Questo metodo trasforma semplicemente la tabella e aggiunge nuove celle secondo necessità.

Il seguente esempio di codice mostra il metodo sopra in funzione:

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