Gestire le celle della tabella nelle presentazioni usando C++

Panoramica

Aspose.Slides consente di accedere e modificare le celle delle tabelle nelle presentazioni PowerPoint. Questo articolo spiega come identificare le celle di tabella unite, rimuovere i bordi delle celle, gestire la numerazione delle celle dopo l’unione o la divisione delle celle, cambiare il colore di sfondo di una cella e aggiungere un’immagine all’interno di una cella di tabella. Gli esempi mostrano come creare o aprire una presentazione, ottenere una tabella da una diapositiva, aggiornare la formattazione delle celle tramite le proprietà della cella e salvare la presentazione modificata come file PPTX.

Aspose.Slides utilizza indici basati su zero per accedere alle celle delle tabelle nell’ordine (colonna, riga).

Identificare una cella di tabella unita

L’esempio apre una presentazione esistente e accede alla prima forma nella prima diapositiva come tabella. Si assume che la diapositiva e la forma esistano e che la forma sia una tabella. Quindi itera attraverso tutte le righe e le colonne e utilizza get_IsMergedCell per identificare le celle nelle regioni unite. Per ogni corrispondenza, stampa le coordinate della cella nell’ordine riga;colonna, get_RowSpan, get_ColSpan, e le coordinate di inizio della regione, get_FirstRowIndex e get_FirstColumnIndex.

#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/IShapeCollection.h>
#include <DOM/Table/ITable.h>
#include <DOM/Table/ICell.h>
#include <system/smart_ptr.h>
#include <DOM/Table/IRowCollection.h>
#include <DOM/Table/IColumnCollection.h>
#include <system/console.h>

using namespace Aspose::Slides;
using namespace System;

auto presentation = MakeObject<Presentation>(u"presentation_with_table.pptx");
auto slide = presentation->get_Slide(0);
auto table = ExplicitCast<ITable>(slide->get_Shape(0));

auto rowCount = table->get_Rows()->get_Count();
for (auto rowIndex = 0; rowIndex < rowCount; rowIndex++)
{
    auto columnCount = table->get_Columns()->get_Count();
    for (auto columnIndex = 0; columnIndex < columnCount; columnIndex++)
    {
        auto cell = table->idx_get(columnIndex, rowIndex);
        if (cell->get_IsMergedCell())
        {
            Console::WriteLine(u"Cell {0};{1} belongs to a merged region with RowSpan={2} and ColSpan={3} starting at {4};{5}.", rowIndex, columnIndex, cell->get_RowSpan(), cell->get_ColSpan(), cell->get_FirstRowIndex(), cell->get_FirstColumnIndex());
        }
    }
}

Rimuovere i bordi della cella di tabella

Crea una Presentation e aggiungi una tabella alla sua prima diapositiva con AddTable. Le larghezze delle colonne, le altezze delle righe e la posizione della tabella sono specificate in punti. L’esempio imposta tutti e quattro i bordi della cella a FillType::NoFill, rendendoli invisibili.

#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/IShapeCollection.h>
#include <DOM/Table/ITable.h>
#include <DOM/Table/ICell.h>
#include <system/smart_ptr.h>
#include <DOM/FillType.h>
#include <DOM/ILineFormat.h>
#include <DOM/ILineFillFormat.h>
#include <DOM/Table/ICellFormat.h>
#include <DOM/Table/IRow.h>
#include <DOM/Table/IRowCollection.h>
#include <system/enumerator_adapter.h>
#include <Export/SaveFormat.h>
#include <system/array.h>

using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace System;

auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto columnWidths = MakeArray<double>({50, 50, 50, 50});
auto rowHeights = MakeArray<double>({50, 30, 30, 30, 30});
auto table = slide->get_Shapes()->AddTable(100, 50, columnWidths, rowHeights);

for (const auto& row : IterateOver(table->get_Rows()))
    for (const auto& cell : IterateOver(row))
    {
        cell->get_CellFormat()->get_BorderTop()->get_FillFormat()->set_FillType(FillType::NoFill);
        cell->get_CellFormat()->get_BorderBottom()->get_FillFormat()->set_FillType(FillType::NoFill);
        cell->get_CellFormat()->get_BorderLeft()->get_FillFormat()->set_FillType(FillType::NoFill);
        cell->get_CellFormat()->get_BorderRight()->get_FillFormat()->set_FillType(FillType::NoFill);
    }

presentation->Save(u"table.pptx", SaveFormat::Pptx);

Aggiungere bordi diagonali alla cella

Usa get_BorderDiagonalDown per disegnare una linea dall’angolo in alto a sinistra a quello in basso a destra e get_BorderDiagonalUp per disegnare una linea dall’angolo in basso a sinistra a quello in alto a destra. Una diagonale può segnare un’intestazione di angolo; entrambe le diagonali possono formare una X per indicare che la cella non è applicabile.

Ogni diagonale è un ILineFormat. Usa get_FillFormat per accedere al riempimento, chiama set_FillType con FillType::Solid e scegli un colore tramite get_SolidFillColor. Imposta lo spessore della linea con set_Width in punti.

L’esempio crea tre celle in una riga: una diagonale rossa verso il basso, una diagonale blu verso l’alto e entrambe le diagonali. Lascia inalterati i bordi superiore, inferiore, sinistro e destro della cella.

#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/IShapeCollection.h>
#include <DOM/Table/ITable.h>
#include <DOM/Table/ICell.h>
#include <DOM/Table/ICellFormat.h>
#include <DOM/ILineFormat.h>
#include <DOM/ILineFillFormat.h>
#include <DOM/IColorFormat.h>
#include <DOM/FillType.h>
#include <Export/SaveFormat.h>
#include <system/smart_ptr.h>
#include <system/array.h>
#include <drawing/color.h>

using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace System;
using namespace System::Drawing;

auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto columnWidths = MakeArray<double>({210, 210, 210});
auto rowHeights = MakeArray<double>({160});
auto table = slide->get_Shapes()->AddTable(45, 130, columnWidths, rowHeights);

auto downwardBorder = table->idx_get(0, 0)->get_CellFormat()->get_BorderDiagonalDown();
downwardBorder->get_FillFormat()->set_FillType(FillType::Solid);
downwardBorder->get_FillFormat()->get_SolidFillColor()->set_Color(Color::get_Red());
downwardBorder->set_Width(3);

auto upwardBorder = table->idx_get(1, 0)->get_CellFormat()->get_BorderDiagonalUp();
upwardBorder->get_FillFormat()->set_FillType(FillType::Solid);
upwardBorder->get_FillFormat()->get_SolidFillColor()->set_Color(Color::get_Blue());
upwardBorder->set_Width(5);

auto crossDownwardBorder = table->idx_get(2, 0)->get_CellFormat()->get_BorderDiagonalDown();
crossDownwardBorder->get_FillFormat()->set_FillType(FillType::Solid);
crossDownwardBorder->get_FillFormat()->get_SolidFillColor()->set_Color(Color::get_Red());
crossDownwardBorder->set_Width(3);

auto crossUpwardBorder = table->idx_get(2, 0)->get_CellFormat()->get_BorderDiagonalUp();
crossUpwardBorder->get_FillFormat()->set_FillType(FillType::Solid);
crossUpwardBorder->get_FillFormat()->get_SolidFillColor()->set_Color(Color::get_Blue());
crossUpwardBorder->set_Width(5);

presentation->Save(u"diagonal_cell_borders.pptx", SaveFormat::Pptx);

Una diagonale è una proprietà di formattazione, non una divisione della cella. Ogni cella conserva un unico frame di testo accessibile tramite get_TextFrame; le regioni ai due lati di una diagonale non possono essere modificate indipendentemente.

La tabella salvata, renderizzata in Microsoft PowerPoint:

Tre celle di tabella mostrano una diagonale rossa dall’angolo in alto a sinistra a quello in basso a destra, una diagonale blu dall’angolo in basso a sinistra a quello in alto a destra e entrambe le diagonali che formano una X.

Da sinistra a destra: diagonale verso il basso (rossa, 3 pt), diagonale verso l’alto (blu, 5 pt) e entrambe le diagonali.

Unire le celle della tabella

Usa MergeCells per combinare un intervallo rettangolare di celle della tabella in una singola cella. Specifica le celle agli angoli in alto a sinistra e in basso a destra dell’intervallo. L’ultimo argomento controlla se l’unione può includere celle al di fuori dell’intervallo specificato; false mantiene l’unione all’interno di quell’intervallo.

L’esempio crea una tabella 4×4 con colonne e righe da 70 punti, poi unisce le quattro celle centrali da (1, 1) a (2, 2). La cella risultante occupa due colonne e due righe, mentre la griglia sottostante della tabella mantiene quattro colonne e quattro righe. Per accedere al contenuto o alla formattazione della cella unita, usa la sua posizione in alto a sinistra: table->idx_get(1, 1) in questo esempio. Le altre posizioni nell’intervallo unito rimangono parte della griglia della tabella, quindi gli indici delle celle al di fuori dell’intervallo non cambiano.

#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/IShapeCollection.h>
#include <DOM/Table/ITable.h>
#include <DOM/Table/ICell.h>
#include <system/smart_ptr.h>
#include <Export/SaveFormat.h>
#include <system/array.h>

using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace System;

auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto columnWidths = MakeArray<double>({70, 70, 70, 70});
auto rowHeights = MakeArray<double>({70, 70, 70, 70});
auto table = slide->get_Shapes()->AddTable(100, 50, columnWidths, rowHeights);

table->MergeCells(table->idx_get(1, 1), table->idx_get(2, 2), false);

presentation->Save(u"merged_cells.pptx", SaveFormat::Pptx);

Dividere le celle della tabella

L’unione delle celle nell’esempio precedente preserva la griglia della tabella. Dividere una cella può introdurre una nuova colonna nella griglia e modificare gli indici di colonna delle celle alla sua destra. Aspose.Slides segue il modello di griglia delle tabelle di PowerPoint.

Questo esempio crea una tabella 4×4 con colonne e righe da 70 punti e chiama SplitByWidth sulla cella (1, 1). Metà della larghezza di 70 punti della cella viene passata per creare due celle di uguale larghezza.

Dopo questa divisione, le due metà sono accessibili come table->idx_get(1, 1) e table->idx_get(2, 1). La griglia della tabella ora ha cinque colonne: le celle originariamente nelle colonne 2 e 3 si spostano rispettivamente nelle colonne 3 e 4. Gli indici di riga rimangono invariati. Usa questi indici di colonna aggiornati quando accedi alle celle dopo la divisione.

#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/IShapeCollection.h>
#include <DOM/Table/ITable.h>
#include <DOM/Table/ICell.h>
#include <system/smart_ptr.h>
#include <Export/SaveFormat.h>
#include <system/array.h>

using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace System;

auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto columnWidths = MakeArray<double>({70, 70, 70, 70});
auto rowHeights = MakeArray<double>({70, 70, 70, 70});
auto table = slide->get_Shapes()->AddTable(100, 50, columnWidths, rowHeights);

table->idx_get(1, 1)->SplitByWidth(table->idx_get(1, 1)->get_Width() / 2);

presentation->Save(u"split_cells.pptx", SaveFormat::Pptx);

Una cella non unita da 70 punti si divide in due celle da 35 punti, aggiungendo una quinta colonna di griglia e spostando gli indici a destra.

La divisione della larghezza riguarda la cella (1, 1), usando indici basati su zero (colonna, riga). Le altre righe mantengono una cella che si estende su entrambe le nuove posizioni di colonna.

Dividere le celle unite per estensione di riga o colonna

Per preparare le celle modello unite alla popolazione dei dati, usa SplitByRowSpan per dividere lungo un confine di riga esistente, oppure SplitByColSpan per dividere lungo un confine di colonna.

L’argomento index conta le righe nella parte superiore o le colonne nella parte sinistra della divisione; è relativo alla regione unita:

L’esempio presuppone che una presentazione contenga una tabella come prima forma nella prima diapositiva, con (1, 2) e (1, 3) uniti verticalmente. Partendo dalla posizione inferiore, utilizza get_FirstColumnIndex e get_FirstRowIndex per localizzare l’origine e verifica entrambi gli span. SplitByRowSpan(1) separa quindi le righe 2 e 3 per i nomi dei prodotti. Per un’unione orizzontale a due colonne, usa invece SplitByColSpan(1).

#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/IShapeCollection.h>
#include <DOM/Table/ITable.h>
#include <DOM/Table/ICell.h>
#include <system/smart_ptr.h>
#include <DOM/ITextFrame.h>
#include <system/console.h>
#include <Export/SaveFormat.h>

using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace System;

auto presentation = MakeObject<Presentation>(u"table_template.pptx");
auto slide = presentation->get_Slide(0);
auto table = ExplicitCast<ITable>(slide->get_Shape(0));

auto selectedCell = table->idx_get(1, 3);
auto firstColumnIndex = selectedCell->get_FirstColumnIndex();
auto firstRowIndex = selectedCell->get_FirstRowIndex();
auto mergedCell = table->idx_get(firstColumnIndex, firstRowIndex);

if (mergedCell->get_IsMergedCell() && mergedCell->get_RowSpan() == 2 && mergedCell->get_ColSpan() == 1)
{
    mergedCell->SplitByRowSpan(1);

    // Recupera le celle risultanti dalla tabella dopo la divisione.
    auto upperCell = table->idx_get(firstColumnIndex, firstRowIndex);
    auto lowerCell = table->idx_get(firstColumnIndex, firstRowIndex + 1);
    Console::WriteLine(u"Upper cell merged: {0}", upperCell->get_IsMergedCell());
    Console::WriteLine(u"Lower cell merged: {0}", lowerCell->get_IsMergedCell());

    upperCell->get_TextFrame()->set_Text(u"Product A");
    lowerCell->get_TextFrame()->set_Text(u"Product B");

    presentation->Save(u"split_template.pptx", SaveFormat::Pptx);
}
else
{
    Console::WriteLine(u"Select a merged region spanning exactly two rows and one column.");
}

La griglia della tabella e gli indici delle celle circostanti rimangono invariati. Recupera le celle risultanti tramite le loro coordinate; qui entrambe hanno span di 1 e get_IsMergedCell restituisce False. Regioni più grandi possono rimanere parzialmente unite dopo una divisione.

Il testo originale e la sua formattazione rimangono nella cella superiore (o sinistra); la nuova cella è vuota ma eredita la formattazione della cella come riempimento, bordi e margini. Popola le celle dopo la divisione e imposta esplicitamente qualsiasi formattazione del testo richiesta.

La presentazione salvata contiene celle separate “Product A” e “Product B” con la formattazione della cella modello mantenuta. Consulta il Cell API Reference per i dettagli.

Dividere una cella a un’altezza specifica

SplitByHeight richiede l’altezza della parte superiore in punti. SplitByRowSpan richiede il numero di righe di griglia esistenti nella parte superiore. Per centrare una cella da 40 punti nella colonna di destra, sottrai 40 dall’altezza reale della cella e distribuisci lo spazio rimanente equamente sopra e sotto di essa.

#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/IShapeCollection.h>
#include <DOM/Table/ITable.h>
#include <DOM/Table/ICell.h>
#include <DOM/ITextFrame.h>
#include <Export/SaveFormat.h>
#include <system/array.h>
#include <system/smart_ptr.h>

using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace System;

auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto columnWidths = MakeArray<double>({160, 160});
auto rowHeights = MakeArray<double>({140});

auto table = slide->get_Shapes()->AddTable(50, 50, columnWidths, rowHeights);
table->idx_get(0, 0)->get_TextFrame()->set_Text(u"Left");

auto height = table->idx_get(1, 0)->get_Height();
auto margin = (height - 40) / 2;

table->idx_get(1, 0)->SplitByHeight(margin);
table->idx_get(1, 1)->SplitByHeight(40);
table->idx_get(1, 1)->get_TextFrame()->set_Text(u"Middle");

presentation->Save(u"split_by_height.pptx", SaveFormat::Pptx);

La prima divisione aggiunge una riga di griglia, lasciando i 90 punti inferiori in (1, 1). La seconda divisione prende quella cella e aggiunge un’altra riga sotto di essa. La colonna di destra ora contiene (1, 0) a 50 punti (margin), (1, 1) a 40 punti e (1, 2) a 50 punti (margin). La cella sinistra si estende su tutte e tre le righe alla sua altezza originale di 140 punti.

La cella sinistra si estende per l’intera altezza della tabella accanto a tre celle con “Middle” al centro.

Modificare il colore di sfondo della cella di tabella

Questo esempio crea una tabella con colonne da 150 punti e righe da 50 punti. Usa set_FillType per selezionare un riempimento solido e get_SolidFillColor per accedere al colore di riempimento e impostarlo su rosso per la cella (2, 3), nella terza colonna e quarta riga.

#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/IShapeCollection.h>
#include <DOM/Table/ITable.h>
#include <DOM/Table/ICell.h>
#include <system/smart_ptr.h>
#include <DOM/FillType.h>
#include <DOM/IColorFormat.h>
#include <DOM/IFillFormat.h>
#include <DOM/Table/ICellFormat.h>
#include <drawing/color.h>
#include <Export/SaveFormat.h>
#include <system/array.h>

using namespace System::Drawing;
using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace System;

auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto columnWidths = MakeArray<double>({150, 150, 150, 150});
auto rowHeights = MakeArray<double>({50, 50, 50, 50, 50});
auto table = slide->get_Shapes()->AddTable(50, 50, columnWidths, rowHeights);

auto cell = table->idx_get(2, 3);
cell->get_CellFormat()->get_FillFormat()->set_FillType(FillType::Solid);
cell->get_CellFormat()->get_FillFormat()->get_SolidFillColor()->set_Color(Color::get_Red());

presentation->Save(u"cell_background_color.pptx", SaveFormat::Pptx);

Aggiungere un’immagine all’interno di una cella di tabella

Posiziona l’immagine di input nella directory di lavoro prima di eseguire questo esempio. L’immagine viene caricata con Images::FromFile e aggiunta alla collezione di immagini della presentazione con AddImage. Viene poi assegnata l’immagine al riempimento immagine della cella (0, 0), la prima cella della tabella.

PictureFillMode::Stretch allunga l’immagine per riempire la cella, il che può modificare il rapporto di aspetto. Le larghezze delle colonne e le altezze delle righe sono in punti. L’immagine caricata viene eliminata dopo essere stata aggiunta alla presentazione.

#include <DOM/Presentation.h>
#include <DOM/ISlide.h>
#include <DOM/IShapeCollection.h>
#include <DOM/Table/ITable.h>
#include <DOM/Table/ICell.h>
#include <system/smart_ptr.h>
#include <DOM/FillType.h>
#include <DOM/IImageCollection.h>
#include <IImage.h>
#include <DOM/IPPImage.h>
#include <DOM/IFillFormat.h>
#include <DOM/IPictureFillFormat.h>
#include <DOM/ISlidesPicture.h>
#include <DOM/PictureFillMode.h>
#include <DOM/Table/ICellFormat.h>
#include <Util/Images.h>
#include <Export/SaveFormat.h>
#include <system/array.h>

using namespace Aspose::Slides;
using namespace Aspose::Slides::Export;
using namespace System;

auto presentation = MakeObject<Presentation>();
auto slide = presentation->get_Slide(0);

auto columnWidths = MakeArray<double>({150, 150, 150, 150});
auto rowHeights = MakeArray<double>({100, 100, 100, 100, 90});
auto table = slide->get_Shapes()->AddTable(50, 50, columnWidths, rowHeights);

auto image = Images::FromFile(u"aspose_logo.jpg");
auto ppImage = presentation->get_Images()->AddImage(image);
image->Dispose();

table->idx_get(0, 0)->get_CellFormat()->get_FillFormat()->set_FillType(FillType::Picture);
table->idx_get(0, 0)->get_CellFormat()->get_FillFormat()->get_PictureFillFormat()->set_PictureFillMode(PictureFillMode::Stretch);
table->idx_get(0, 0)->get_CellFormat()->get_FillFormat()->get_PictureFillFormat()->get_Picture()->set_Image(ppImage);

presentation->Save(u"table_cell_with_image.pptx", SaveFormat::Pptx);

FAQ

Posso impostare spessori e stili di linea diversi per lati diversi della stessa cella?

Sì. I bordi top/bottom/left/right hanno proprietà separate, quindi spessore e stile di ciascun lato possono differire.

Cosa succede all’immagine se modifico la dimensione della colonna/riga dopo aver impostato un’immagine come sfondo della cella?

Il comportamento dipende dalla fill mode (stretch/tile). Con lo stretching, l’immagine si adatta alla nuova cella; con il tiling, le tessere vengono ricalcolate.

Posso assegnare un collegamento ipertestuale a tutto il contenuto di una cella?

Hyperlinks sono impostati a livello di testo (porzione) all’interno del frame di testo della cella o a livello dell’intera tabella/forma. In pratica, assegni il collegamento a una porzione o a tutto il testo nella cella.

Posso impostare font diversi all’interno della stessa cella?

Sì. Il frame di testo di una cella supporta portions (segmenti) con formattazione indipendente—famiglia di font, stile, dimensione e colore.